package com.sg.service.biz.bff.impl;


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.biz.bff.req.*;
import com.sg.dto.biz.bff.res.*;
import com.sg.service.biz.bff.OffStateService;
import com.wicket.okrapp.integration.*;
import com.wicket.okrapp.integration.dto.*;
import com.sg.common.exception.Assert;
import com.wicket.okrbff.common.exception.BizException;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import com.wicket.okrcomponent.integration.OffStateService;
import com.wicket.okrcomponent.integration.TemplateEngineService;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrframework.integration.AppSceneService;
import com.wicket.okrframework.integration.InductionRecordService;
import com.wicket.okrframework.integration.OffStateService;
import com.wicket.okrframework.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class OffStateServiceImpl implements OffStateService {
    @Resource
    com.sg.service.biz.app.OffStateService fwAppOffStateClient;
    @Resource
    com.sg.service.biz.framework.AppSceneService fwBaseAppSceneClient;
    @Resource
    com.sg.service.biz.framework.InductionRecordService fwBaseInductionRecordClient;
    @Resource
    com.sg.service.biz.framework.OffStateService fwBaseOffStateClient;
    @Resource
    com.sg.service.biz.component.OffStateService fwCompOffStateClient;
    @Resource
    private RedisUtil redisUtil;
    @Resource
    com.sg.service.biz.app.TargetCycleService fwAppTargetCycleClient;
    @Resource
    com.sg.service.biz.app.TargetContentService fwAppTargetContentClient;
    @Resource
    com.sg.service.biz.app.EvaSystemService fwAppEvaSystemClient;
    @Resource
    com.sg.service.biz.component.TemplateEngineService fwCompTemplateEngineClient;

    @Resource
    com.sg.service.biz.app.InterfaceModeService fwAppInterfaceModeClient;
    @Resource
    com.sg.service.biz.app.ExecuteProgressService fwAppExecuteProgressClient;
    @Resource
    com.sg.service.biz.component.InterfaceModeService fwCompInterfaceModeClient;


    /**
     * B1-1查询状态校验项列表（公共）
     */
    @Trace(operationName = "B1-1查询状态校验项列表（公共）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryCheckItemStatListComRespDto queryCheckItemStatListCom(BffQueryCheckItemStatListComReqDto reqDto) {

        // 步骤0: D1-1查询状态校验项列表 - queryCheckItemStatList
        QueryCheckItemStatListRespDto queryCheckItemStatListRespDto = null;
        QueryCheckItemStatListReqDto queryCheckItemStatListReqDto = new QueryCheckItemStatListReqDto();
        if (reqDto != null) {
            queryCheckItemStatListReqDto.setCheckItemCode(reqDto.getCheckItemCode());// sourceId:19709_1
            queryCheckItemStatListReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());// sourceId:19710_1
            queryCheckItemStatListReqDto.setEntityId(reqDto.getEntityId());// sourceId:19711_1
        }

        /* D1-1查询状态校验项列表[960] */
        queryCheckItemStatListRespDto = fwBaseOffStateClient.queryCheckItemStatList(queryCheckItemStatListReqDto)
                .getData();

        // 步骤1: D3-11查列表检查项 - queryCheckItemList
        QueryCheckItemListRespDto queryCheckItemListRespDto = null;
        QueryCheckItemListReqDto queryCheckItemListReqDto = new QueryCheckItemListReqDto();
        queryCheckItemListReqDto.setBizSceneCode("ORG_CHECK_ITEM");// CUSTOM_CONVENTION//sourceId:43038_1
        queryCheckItemListReqDto.setSubjectLifeCycle("CURRENTLY_VALID");// sourceId:43039_1

        /* D3-11查列表检查项[888] */
        queryCheckItemListRespDto = fwAppOffStateClient.queryCheckItemList(queryCheckItemListReqDto).getData();

        BffQueryCheckItemStatListComRespDto retData = new BffQueryCheckItemStatListComRespDto();
        // todo
        // master集合数量为0,请联系业务设计人员检查,是否设置了master集合?;关联关系如下:retData.getCheckItemStatList().setStatusCheckItemId(queryCheckItemStatListRespDto.getCheckItemStatList().getStatusCheckItemId());retData.getCheckItemStatList().setCheckItemCode(queryCheckItemStatListRespDto.getCheckItemStatList().getCheckItemCode());retData.getCheckItemStatList().setCheckItemName(queryCheckItemListRespDto.getCheckItemList().getCheckItemName());retData.getCheckItemStatList().setIsComplete(queryCheckItemStatListRespDto.getCheckItemStatList().getIsComplete())

        return retData;
    }

    /**
     * B1-1查询状态校验项详情（公共）[955]
     * gen by moon at 8/10/2022, 3:31:28 AM
     */
    @Trace(operationName = "B1-1查询状态校验项详情（公共）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryCheckItemStatDetailComRespDto queryCheckItemStatDetailCom(BffQueryCheckItemStatDetailComReqDto reqDto) {


        QueryCheckItemStatDetailRespDto queryCheckItemStatDetailRespDto_1 = null;
//步骤0: D1-1查询状态校验项详情 - queryCheckItemStatDetail
        QueryCheckItemStatDetailRespDto queryCheckItemStatDetailRespDto = null;
        QueryCheckItemStatDetailReqDto queryCheckItemStatDetailReqDto = new QueryCheckItemStatDetailReqDto();
        if (reqDto != null) {
            queryCheckItemStatDetailReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:19332_1
            queryCheckItemStatDetailReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:19333_1
            queryCheckItemStatDetailReqDto.setEntityId(reqDto.getEntityId());//sourceId:19334_1
        }

        /*D1-1查询状态校验项详情[954]   */

        queryCheckItemStatDetailRespDto = fwBaseOffStateClient.queryCheckItemStatDetail(queryCheckItemStatDetailReqDto).getData();

        queryCheckItemStatDetailRespDto_1 = queryCheckItemStatDetailRespDto;

        BffQueryCheckItemStatDetailComRespDto retData = new BffQueryCheckItemStatDetailComRespDto();
        if (queryCheckItemStatDetailRespDto_1 != null) {
            retData.setIsComplete(queryCheckItemStatDetailRespDto_1.getIsComplete());//sourceId:19342_1
        }


        return retData;
    }

    /**
     * B1-1修改状态校验项(（公共）[952]
     * gen by moon at 8/10/2022, 3:31:24 AM
     */
    @Trace(operationName = "B1-1修改状态校验项(（公共）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateCheckItemStatComRespDto updateCheckItemStatCom(BffUpdateCheckItemStatComReqDto reqDto) {


        //步骤0: D1-1修改检查项状态(公共) - updateCheckItemStatCom
        UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
        UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto = new UpdateCheckItemStatComReqDto();
        if (reqDto != null) {
            updateCheckItemStatComReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:143264_1
            updateCheckItemStatComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:143265_1
            updateCheckItemStatComReqDto.setEntityId(reqDto.getEntityId());//sourceId:143266_1
            updateCheckItemStatComReqDto.setIsComplete(reqDto.getIsComplete());//sourceId:19232_1
        }

        /*D1-1修改检查项状态(公共)[947]   */
        Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(), "B1-1修改状态校验项(（公共）-D1-1修改检查项状态(公共)-检查项标识不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(), "B1-1修改状态校验项(（公共）-D1-1修改检查项状态(公共)-内容对象类型编码不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getEntityId(), "B1-1修改状态校验项(（公共）-D1-1修改检查项状态(公共)-内容对象实例ID不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(), "B1-1修改状态校验项(（公共）-D1-1修改检查项状态(公共)-是否已完成不能为空", false);
        updateCheckItemStatComRespDto = fwBaseOffStateClient.updateCheckItemStatCom(updateCheckItemStatComReqDto).getData();


        BffUpdateCheckItemStatComRespDto retData = new BffUpdateCheckItemStatComRespDto();


        return retData;
    }

    /**
     * B1-1更新组织成员管理检查项等(管理)(公共)[952]
     * gen by moon at 8/26/2022, 7:31:59 PM
     */
    @Trace(operationName = "B1-1更新组织成员管理检查项等(管理)(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffRefreshOrgMemberMgtCheckEtcComRespDto refreshOrgMemberMgtCheckEtcCom(BffRefreshOrgMemberMgtCheckEtcComReqDto reqDto) {


        //步骤0: D1-3更新组织成员管理检查项等 - refreshOrgMemberMgtCheckEtc
        RefreshOrgMemberMgtCheckEtcRespDto refreshOrgMemberMgtCheckEtcRespDto = null;
        RefreshOrgMemberMgtCheckEtcReqDto refreshOrgMemberMgtCheckEtcReqDto = new RefreshOrgMemberMgtCheckEtcReqDto();
        if (reqDto != null) {
            refreshOrgMemberMgtCheckEtcReqDto.setOrganizationId(reqDto.getOrganizationId());//sourceId:257133_1
            refreshOrgMemberMgtCheckEtcReqDto.setIsComplete(reqDto.getIsComplete());//sourceId:257134_1
        }

        /*D1-3更新组织成员管理检查项等[4184]   */
        Assert.isNull(refreshOrgMemberMgtCheckEtcReqDto.getOrganizationId(), "B1-1更新组织成员管理检查项等(管理)(公共)-D1-3更新组织成员管理检查项等-组织ID不能为空", false);
        Assert.isNull(refreshOrgMemberMgtCheckEtcReqDto.getIsComplete(), "B1-1更新组织成员管理检查项等(管理)(公共)-D1-3更新组织成员管理检查项等-是否已完成不能为空", false);
        refreshOrgMemberMgtCheckEtcRespDto = fwBaseOffStateClient.refreshOrgMemberMgtCheckEtc(refreshOrgMemberMgtCheckEtcReqDto).getData();


        BffRefreshOrgMemberMgtCheckEtcComRespDto retData = new BffRefreshOrgMemberMgtCheckEtcComRespDto();


        return retData;
    }

    /**
     * B3-11批量增目标校验项状态(管理)[3126]
     * gen by moon at 10/7/2022, 2:13:53 AM
     */
    @Trace(operationName = "B3-11批量增目标校验项状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffBatchAddTargetCheckItemStatRespDto batchAddTargetCheckItemStat(BffBatchAddTargetCheckItemStatReqDto reqDto) {


        //步骤0: D3-11新增业务应用校验项状态(公共) - addBizAppCheckItemStatCom
        AddBizAppCheckItemStatComRespDto addBizAppCheckItemStatComRespDto = null;
        AddBizAppCheckItemStatComReqDto addBizAppCheckItemStatComReqDto = new AddBizAppCheckItemStatComReqDto();
        if (reqDto != null) {
            addBizAppCheckItemStatComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:367770_1
            addBizAppCheckItemStatComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:367771_1
        }

        /*D3-11新增业务应用校验项状态(公共)[3120]   */
        Assert.isNull(addBizAppCheckItemStatComReqDto.getTargetId(), "B3-11批量增目标校验项状态(管理)-D3-11新增业务应用校验项状态(公共)-目标ID不能为空", false);
        Assert.isNull(addBizAppCheckItemStatComReqDto.getEvaluationTemplateId(), "B3-11批量增目标校验项状态(管理)-D3-11新增业务应用校验项状态(公共)-冗余评价模板ID不能为空", false);
        addBizAppCheckItemStatComRespDto = fwAppOffStateClient.addBizAppCheckItemStatCom(addBizAppCheckItemStatComReqDto).getData();


        BffBatchAddTargetCheckItemStatRespDto retData = new BffBatchAddTargetCheckItemStatRespDto();


        return retData;
    }

    /**
     * B3-13新增高层当前步骤(管理)[3127]
     * gen by moon at 8/29/2022, 1:21:51 AM
     */
    @Trace(operationName = "B3-13新增高层当前步骤(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAddTopCurrentBstepRespDto addTopCurrentBstep(BffAddTopCurrentBstepReqDto reqDto) {


        AddBizAppServiceContCurrentBstepComRespDto addBizAppServiceContCurrentBstepComRespDto_1 = null;
//步骤0: D3-11新增业务服务内容当前步骤(公共) - addBizAppServiceContCurrentBstepCom
        AddBizAppServiceContCurrentBstepComRespDto addBizAppServiceContCurrentBstepComRespDto = null;
        AddBizAppServiceContCurrentBstepComReqDto addBizAppServiceContCurrentBstepComReqDto = new AddBizAppServiceContCurrentBstepComReqDto();
        addBizAppServiceContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_TEMPLATE");//sourceId:108879_1
        addBizAppServiceContCurrentBstepComReqDto.setBizSceneCode("TOP_PLAN_PREP");//CUSTOM_CONVENTION//sourceId:108882_1
        addBizAppServiceContCurrentBstepComReqDto.setOrderNumber(1L);//CUSTOM_CONVENTION//sourceId:108883_1
        if (reqDto != null) {
            addBizAppServiceContCurrentBstepComReqDto.setEntityId(reqDto.getEntityId());//sourceId:108880_1
        }

        /*D3-11新增业务服务内容当前步骤(公共)[2428]   */
        Assert.isNull(addBizAppServiceContCurrentBstepComReqDto.getEntityId(), "B3-13新增高层当前步骤(管理)-D3-11新增业务服务内容当前步骤(公共)-步骤内容实例ID不能为空", false);
        Assert.isNull(addBizAppServiceContCurrentBstepComReqDto.getStepObj(), "B3-13新增高层当前步骤(管理)-D3-11新增业务服务内容当前步骤(公共)-步骤使用对象表不能为空", false);
        Assert.isNull(addBizAppServiceContCurrentBstepComReqDto.getBizSceneCode(), "B3-13新增高层当前步骤(管理)-D3-11新增业务服务内容当前步骤(公共)-业务场景标识不能为空", false);
        Assert.isNull(addBizAppServiceContCurrentBstepComReqDto.getOrderNumber(), "B3-13新增高层当前步骤(管理)-D3-11新增业务服务内容当前步骤(公共)-排序不能为空", false);
        addBizAppServiceContCurrentBstepComRespDto = fwAppOffStateClient.addBizAppServiceContCurrentBstepCom(addBizAppServiceContCurrentBstepComReqDto).getData();

        addBizAppServiceContCurrentBstepComRespDto_1 = addBizAppServiceContCurrentBstepComRespDto;

        BffAddTopCurrentBstepRespDto retData = new BffAddTopCurrentBstepRespDto();
        if (addBizAppServiceContCurrentBstepComRespDto_1 != null) {
            retData.setBehaviorCurrentStepId(addBizAppServiceContCurrentBstepComRespDto_1.getBehaviorCurrentStepId());//sourceId:108885_1
        }


        return retData;
    }

    /**
     * B3-11设完成高层切换第三步(管理)[2986]
     * gen by moon at 2/7/2024, 4:39:06 AM
     */
    @Trace(operationName = "B3-11设完成高层切换第三步(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffCompleteTopHandoverThreeStepRespDto completeTopHandoverThreeStep(BffCompleteTopHandoverThreeStepReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2执行上并发高中基层步骤变更锁(公共)  61106
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540059_1_61106
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540060_1_61106
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540065_1_61106
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540066_1_61106
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_ERROR_REPORTING");//sourceId:1540067_1_61106
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540061_1_61106
        }

        /*D2执行上并发高中基层步骤变更锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3-11设完成高层切换第三步(管理)-D2执行上并发高中基层步骤变更锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61107

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setDeptTargetWeightSet("1");//CUSTOM_CONVENTION//sourceId:1203498_1_61108
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203499_1_61108
            if (reqDto != null) {
                implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203500_1_61108
            }

            /*D3执行高中基层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptTargetWeightSet(), "B3-11设完成高层切换第三步(管理)-D3执行高中基层导向步骤房间-部门目标权重设置不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11设完成高层切换第三步(管理)-D3执行高中基层导向步骤房间-高/中/基层操作场景不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(), "B3-11设完成高层切换第三步(管理)-D3执行高中基层导向步骤房间-权重设置方式不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1540085_1_61109
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540081_1_61109
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540082_1_61109
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1540084_1_61109
                }

                /*D3执行高中基层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3-11设完成高层切换第三步(管理)-D3执行高中基层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3-11设完成高层切换第三步(管理)-D3执行高中基层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3-11设完成高层切换第三步(管理)-D3执行高中基层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3-11设完成高层切换第三步(管理)-D3执行高中基层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
                //if(D3执行高中基层当前步骤判断(公共).是否相等 等于 否)  61110

                CompleteTopHandoverThreeStepRespDto completeTopHandoverThreeStepRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    CompleteTopHandoverThreeStepReqDto completeTopHandoverThreeStepReqDto = new CompleteTopHandoverThreeStepReqDto();
                    if (reqDto != null) {
                        completeTopHandoverThreeStepReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:849703_1_61111
                        completeTopHandoverThreeStepReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:849704_1_61111
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        completeTopHandoverThreeStepReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203478_1_61111
                    }

                    /*D3-11设完成高层切换第三步[3950]   */
                    Assert.isNull(completeTopHandoverThreeStepReqDto.getTargetId(), "B3-11设完成高层切换第三步(管理)-D3-11设完成高层切换第三步-冗余目标ID不能为空", false);
                    Assert.isNull(completeTopHandoverThreeStepReqDto.getEvaluationTemplateId(), "B3-11设完成高层切换第三步(管理)-D3-11设完成高层切换第三步-冗余评价模板ID不能为空", false);
                    Assert.isNull(completeTopHandoverThreeStepReqDto.getStepRoomValue(), "B3-11设完成高层切换第三步(管理)-D3-11设完成高层切换第三步-进入步骤房间值不能为空", false);
                    completeTopHandoverThreeStepRespDto = fwAppOffStateClient.completeTopHandoverThreeStep(completeTopHandoverThreeStepReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540070_1_61116
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540071_1_61116
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540079_1_61116
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540072_1_61116
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3-11设完成高层切换第三步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3-11设完成高层切换第三步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3-11设完成高层切换第三步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3-11设完成高层切换第三步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行高中基层当前步骤判断(公共).是否相等 等于 是)  61112

//异常结束 61113
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61114

//异常结束 61115
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffCompleteTopHandoverThreeStepRespDto retData = new BffCompleteTopHandoverThreeStepRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203497_1
        }


        return retData;
    }

    /**
     * B3-11高层确认设置完成(管理)[2989]
     * gen by moon at 2/7/2024, 4:39:12 AM
     */
    @Trace(operationName = "B3-11高层确认设置完成(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffCompleteTopNotarizeSetAchieveRespDto completeTopNotarizeSetAchieve(BffCompleteTopNotarizeSetAchieveReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2执行上并发高中基层步骤变更锁(公共)  61117
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540086_1_61117
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540087_1_61117
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540092_1_61117
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540093_1_61117
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540094_1_61117
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540088_1_61117
        }

        /*D2执行上并发高中基层步骤变更锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3-11高层确认设置完成(管理)-D2执行上并发高中基层步骤变更锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61118

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203520_1_61119
            implementTopMidBasicGuideStepRoomReqDto.setPlanStaffingAchieve("1");//CUSTOM_CONVENTION//sourceId:1203447_1_61119
            if (reqDto != null) {
                implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203445_1_61119
            }

            /*D3执行高中基层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11高层确认设置完成(管理)-D3执行高中基层导向步骤房间-高/中/基层操作场景不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getPlanStaffingAchieve(), "B3-11高层确认设置完成(管理)-D3执行高中基层导向步骤房间-规划编制完成不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(), "B3-11高层确认设置完成(管理)-D3执行高中基层导向步骤房间-权重设置方式不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1540112_1_61120
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540108_1_61120
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540109_1_61120
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1540111_1_61120
                }

                /*D3执行高中基层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3-11高层确认设置完成(管理)-D3执行高中基层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3-11高层确认设置完成(管理)-D3执行高中基层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3-11高层确认设置完成(管理)-D3执行高中基层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3-11高层确认设置完成(管理)-D3执行高中基层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
                //if(D3执行高中基层当前步骤判断(公共).是否相等 等于 否)  61121

                CompleteTopNotarizeSetAchieveRespDto completeTopNotarizeSetAchieveRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    CompleteTopNotarizeSetAchieveReqDto completeTopNotarizeSetAchieveReqDto = new CompleteTopNotarizeSetAchieveReqDto();
                    if (reqDto != null) {
                        completeTopNotarizeSetAchieveReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:206993_1_61122
                        completeTopNotarizeSetAchieveReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:206994_1_61122
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        completeTopNotarizeSetAchieveReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203443_1_61122
                    }

                    /*D3-11设完成高层确认设置完成[3952]   */
                    Assert.isNull(completeTopNotarizeSetAchieveReqDto.getTargetId(), "B3-11高层确认设置完成(管理)-D3-11设完成高层确认设置完成-冗余目标ID不能为空", false);
                    Assert.isNull(completeTopNotarizeSetAchieveReqDto.getEvaluationTemplateId(), "B3-11高层确认设置完成(管理)-D3-11设完成高层确认设置完成-冗余评价模板ID不能为空", false);
                    Assert.isNull(completeTopNotarizeSetAchieveReqDto.getStepRoomValue(), "B3-11高层确认设置完成(管理)-D3-11设完成高层确认设置完成-进入步骤房间值不能为空", false);
                    completeTopNotarizeSetAchieveRespDto = fwAppOffStateClient.completeTopNotarizeSetAchieve(completeTopNotarizeSetAchieveReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540113_1_61123
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540114_1_61123
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540116_1_61123
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540115_1_61123
                }

                /*D2-执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3-11高层确认设置完成(管理)-D2-执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3-11高层确认设置完成(管理)-D2-执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3-11高层确认设置完成(管理)-D2-执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3-11高层确认设置完成(管理)-D2-执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行高中基层当前步骤判断(公共).是否相等 等于 是)  61124

//异常结束 61125
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61126

//异常结束 61127
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffCompleteTopNotarizeSetAchieveRespDto retData = new BffCompleteTopNotarizeSetAchieveRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203477_1
        }


        return retData;
    }

    /**
     * B3-11高层重新编辑(管理)[2992]
     * gen by moon at 2/7/2024, 4:39:16 AM
     */
    @Trace(operationName = "B3-11高层重新编辑(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateTopEditRespDto updateTopEdit(BffUpdateTopEditReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2执行上并发高中基层步骤变更锁(公共)  61128
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540117_1_61128
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540118_1_61128
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540123_1_61128
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540124_1_61128
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540125_1_61128
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540119_1_61128
        }

        /*D2执行上并发高中基层步骤变更锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3-11高层重新编辑(管理)-D2执行上并发高中基层步骤变更锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61129

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setReedit("1");//CUSTOM_CONVENTION//sourceId:1203293_1_61130
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203286_1_61130
            if (reqDto != null) {
                implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203333_1_61130
            }

            /*D3执行高中基层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getReedit(), "B3-11高层重新编辑(管理)-D3执行高中基层导向步骤房间-重新编辑不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11高层重新编辑(管理)-D3执行高中基层导向步骤房间-高/中/基层操作场景不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(), "B3-11高层重新编辑(管理)-D3执行高中基层导向步骤房间-权重设置方式不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1540143_1_61131
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540139_1_61131
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540140_1_61131
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1540142_1_61131
                }

                /*D3执行高中基层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3-11高层重新编辑(管理)-D3执行高中基层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3-11高层重新编辑(管理)-D3执行高中基层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3-11高层重新编辑(管理)-D3执行高中基层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3-11高层重新编辑(管理)-D3执行高中基层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
                //if(D3执行高中基层当前步骤判断(公共).是否相等 等于 否)  61132

                CancelCompleteTopEditRespDto cancelCompleteTopEditRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    CancelCompleteTopEditReqDto cancelCompleteTopEditReqDto = new CancelCompleteTopEditReqDto();
                    if (reqDto != null) {
                        cancelCompleteTopEditReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:862402_1_61133
                        cancelCompleteTopEditReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:323348_1_61133
                        cancelCompleteTopEditReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:856669_1_61133
                        cancelCompleteTopEditReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856670_1_61133
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        cancelCompleteTopEditReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:849900_1_61133
                    }

                    /*D3-11高层重新编辑[4550]   */
                    Assert.isNull(cancelCompleteTopEditReqDto.getTargetId(), "B3-11高层重新编辑(管理)-D3-11高层重新编辑-冗余目标ID不能为空", false);
                    Assert.isNull(cancelCompleteTopEditReqDto.getEvaluationTemplateId(), "B3-11高层重新编辑(管理)-D3-11高层重新编辑-冗余评价模板ID不能为空", false);
                    Assert.isNull(cancelCompleteTopEditReqDto.getStepRoomValue(), "B3-11高层重新编辑(管理)-D3-11高层重新编辑-进入步骤房间值不能为空", false);
                    Assert.isNull(cancelCompleteTopEditReqDto.getBatchCode(), "B3-11高层重新编辑(管理)-D3-11高层重新编辑-批次标识不能为空", false);
                    Assert.isNull(cancelCompleteTopEditReqDto.getBatchCurrentStatus(), "B3-11高层重新编辑(管理)-D3-11高层重新编辑-批次现状不能为空", false);
                    cancelCompleteTopEditRespDto = fwAppOffStateClient.cancelCompleteTopEdit(cancelCompleteTopEditReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540144_1_61134
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540145_1_61134
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540147_1_61134
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540146_1_61134
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3-11高层重新编辑(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3-11高层重新编辑(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3-11高层重新编辑(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3-11高层重新编辑(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行高中基层当前步骤判断(公共).是否相等 等于 是)  61135

//异常结束 61136
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61137

//异常结束 61138
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffUpdateTopEditRespDto retData = new BffUpdateTopEditRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203338_1
        }


        return retData;
    }

    /**
     * B3-11查高层编制目标任务校验项状态列表(管理)[3009]
     * gen by moon at 10/8/2022, 3:09:48 AM
     */
    @Trace(operationName = "B3-11查高层编制目标任务校验项状态列表(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryTopCompileTargetTaskcheckItemStatListRespDto queryTopCompileTargetTaskcheckItemStatList(BffQueryTopCompileTargetTaskcheckItemStatListReqDto reqDto) {


        QueryTopCompileTargetTaskcheckItemStatListRespDto queryTopCompileTargetTaskcheckItemStatListRespDto_1 = null;
//步骤0: D3-11查询高层编制目标任务校验项状态列表 - queryTopCompileTargetTaskcheckItemStatList
        QueryTopCompileTargetTaskcheckItemStatListRespDto queryTopCompileTargetTaskcheckItemStatListRespDto = null;
        QueryTopCompileTargetTaskcheckItemStatListReqDto queryTopCompileTargetTaskcheckItemStatListReqDto = new QueryTopCompileTargetTaskcheckItemStatListReqDto();
        if (reqDto != null) {
            queryTopCompileTargetTaskcheckItemStatListReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:322839_1
        }

        /*D3-11查询高层编制目标任务校验项状态列表[3010]   */
        Assert.isNull(queryTopCompileTargetTaskcheckItemStatListReqDto.getEntityId(), "B3-11查高层编制目标任务校验项状态列表(管理)-D3-11查询高层编制目标任务校验项状态列表-目标ID不能为空", false);
        queryTopCompileTargetTaskcheckItemStatListRespDto = fwAppOffStateClient.queryTopCompileTargetTaskcheckItemStatList(queryTopCompileTargetTaskcheckItemStatListReqDto).getData();


        queryTopCompileTargetTaskcheckItemStatListRespDto_1 = queryTopCompileTargetTaskcheckItemStatListRespDto;

        BffQueryTopCompileTargetTaskcheckItemStatListRespDto retData = new BffQueryTopCompileTargetTaskcheckItemStatListRespDto();
        if (queryTopCompileTargetTaskcheckItemStatListRespDto_1 != null) {
            retData.setBizAppCheckItemStatList(queryTopCompileTargetTaskcheckItemStatListRespDto_1.getBizAppCheckItemStatList().stream().map(item -> BeanUtil.toBean(item, BffBizAppCheckItemStatDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:322840_1
            retData.setCalcCount(queryTopCompileTargetTaskcheckItemStatListRespDto_1.getCalcCount());//SimpleFieldAssign//sourceId:306199_1
            retData.setAlreadyAccomplishNum(queryTopCompileTargetTaskcheckItemStatListRespDto_1.getAlreadyAccomplishNum());//SimpleFieldAssign//sourceId:306200_1
        }


        return retData;
    }

    /**
     * B2-9查步骤列表(边界)[3055]
     * gen by moon at 10/24/2022, 4:31:54 AM
     */
    @Trace(operationName = "B2-9查步骤列表(边界)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryStepListBorderRespDto queryStepListBorder(BffQueryStepListBorderReqDto reqDto) {


        JudgeTopMidBasicStepRespDto judgeTopMidBasicStepRespDto_1 = null;
//步骤0: D3-9判断高中基层步骤 - judgeTopMidBasicStep
        JudgeTopMidBasicStepRespDto judgeTopMidBasicStepRespDto = null;
        JudgeTopMidBasicStepReqDto judgeTopMidBasicStepReqDto = new JudgeTopMidBasicStepReqDto();
        if (reqDto != null) {
            judgeTopMidBasicStepReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:388494_1
            judgeTopMidBasicStepReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:370627_1
            judgeTopMidBasicStepReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:370628_1
        }

        /*D3-9判断高中基层步骤[4787]   */
        Assert.isNull(judgeTopMidBasicStepReqDto.getBatchOperateScene(), "B2-9查步骤列表(边界)-D3-9判断高中基层步骤-高/中/基层操作场景不能为空", false);
        judgeTopMidBasicStepRespDto = fwAppOffStateClient.judgeTopMidBasicStep(judgeTopMidBasicStepReqDto).getData();


        judgeTopMidBasicStepRespDto_1 = judgeTopMidBasicStepRespDto;

        BffQueryStepListBorderRespDto retData = new BffQueryStepListBorderRespDto();
        if (judgeTopMidBasicStepRespDto_1 != null) {
            retData.setTopMidBasicStepList(judgeTopMidBasicStepRespDto_1.getTopMidBasicStepList().stream().map(item -> BeanUtil.toBean(item, BffTopMidBasicStepDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:388498_1
        }


        return retData;
    }

    /**
     * B3-13查业务服务内容当前步骤(管理)[3056]
     * gen by moon at 10/8/2022, 3:09:59 AM
     */
    @Trace(operationName = "B3-13查业务服务内容当前步骤(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryBizAppServiceContCurrentBstepDetailRespDto queryBizAppServiceContCurrentBstepDetail(BffQueryBizAppServiceContCurrentBstepDetailReqDto reqDto) {


        QueryContCurrentBstepDetailRespDto queryContCurrentBstepDetailRespDto_1 = null;
//步骤0: D3-13查内容当前行为步骤 - queryContCurrentBstepDetail
        QueryContCurrentBstepDetailRespDto queryContCurrentBstepDetailRespDto = null;
        QueryContCurrentBstepDetailReqDto queryContCurrentBstepDetailReqDto = new QueryContCurrentBstepDetailReqDto();
        if (reqDto != null) {
            queryContCurrentBstepDetailReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:101814_1
            queryContCurrentBstepDetailReqDto.setStepObj(reqDto.getStepObj());//SimpleFieldAssign//sourceId:101813_1
        }

        /*D3-13查内容当前行为步骤[2951]   */
        Assert.isNull(queryContCurrentBstepDetailReqDto.getEntityId(), "B3-13查业务服务内容当前步骤(管理)-D3-13查内容当前行为步骤-步骤内容实例ID不能为空", false);
        Assert.isNull(queryContCurrentBstepDetailReqDto.getStepObj(), "B3-13查业务服务内容当前步骤(管理)-D3-13查内容当前行为步骤-步骤使用对象表不能为空", false);
        queryContCurrentBstepDetailRespDto = fwAppOffStateClient.queryContCurrentBstepDetail(queryContCurrentBstepDetailReqDto).getData();


        queryContCurrentBstepDetailRespDto_1 = queryContCurrentBstepDetailRespDto;

        BffQueryBizAppServiceContCurrentBstepDetailRespDto retData = new BffQueryBizAppServiceContCurrentBstepDetailRespDto();
        if (queryContCurrentBstepDetailRespDto_1 != null) {
            retData.setBehaviorCurrentStepId(queryContCurrentBstepDetailRespDto_1.getBehaviorCurrentStepId());//SimpleFieldAssign//sourceId:101818_1
            retData.setStepNameCode(queryContCurrentBstepDetailRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:101819_1
        }


        return retData;
    }

    /**
     * B3-11设基层完成安排(管理)[3059]
     * gen by moon at 10/24/2023, 3:33:33 AM
     */
    @Trace(operationName = "B3-11设基层完成安排(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffCompleteBasicSetAchieveRespDto completeBasicSetAchieve(BffCompleteBasicSetAchieveReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D3执行基层导向步骤房间  51055
        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
        ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
        implementTopMidBasicGuideStepRoomReqDto.setAchieveArrange("1");//CUSTOM_CONVENTION//sourceId:1203718_1_51055
        implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("BASIC");//sourceId:1203719_1_51055

        /*D3执行基层导向步骤房间[7600]   */
        Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getAchieveArrange(), "B3-11设基层完成安排(管理)-D3执行基层导向步骤房间-完成安排不能为空", false);
        Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11设基层完成安排(管理)-D3执行基层导向步骤房间-高/中/基层操作场景不能为空", false);
        implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
        if ((implementTopMidBasicGuideStepRoomRespDto != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null)) {
            //if(D3执行基层导向步骤房间.进入步骤房间值 值不等于空 )  51056

            UpdateBasicSetAchieveComRespDto updateBasicSetAchieveComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                UpdateBasicSetAchieveComReqDto updateBasicSetAchieveComReqDto = new UpdateBasicSetAchieveComReqDto();
                updateBasicSetAchieveComReqDto.setBatchOperateScene("BASIC");//sourceId:1203729_1_51057
                updateBasicSetAchieveComReqDto.setIsComplete("TRUE");//sourceId:1203731_1_51057
                if (reqDto != null) {
                    updateBasicSetAchieveComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:425743_1_51057
                    updateBasicSetAchieveComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:425744_1_51057
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    updateBasicSetAchieveComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203730_1_51057
                }

                /*D3-11修改基层设置完成(公共)[3764]   */
                Assert.isNull(updateBasicSetAchieveComReqDto.getTargetId(), "B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-目标ID不能为空", false);
                Assert.isNull(updateBasicSetAchieveComReqDto.getDeptId(), "B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-部门ID不能为空", false);
                Assert.isNull(updateBasicSetAchieveComReqDto.getBatchOperateScene(), "B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-高/中/基层操作场景不能为空", false);
                Assert.isNull(updateBasicSetAchieveComReqDto.getStepRoomValue(), "B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(updateBasicSetAchieveComReqDto.getIsComplete(), "B3-11设基层完成安排(管理)-D3-11修改基层设置完成(公共)-是否已完成不能为空", false);
                updateBasicSetAchieveComRespDto = fwAppOffStateClient.updateBasicSetAchieveCom(updateBasicSetAchieveComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
        BffCompleteBasicSetAchieveRespDto retData = new BffCompleteBasicSetAchieveRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203732_1
        }


        return retData;
    }

    /**
     * B3-13判断高层第1步可进入的房间(管理)[4403]
     * gen by moon at 10/15/2022, 10:26:51 PM
     */
    @Trace(operationName = "B3-13判断高层第1步可进入的房间(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffJudgeTopStepOneOperateTypeRespDto judgeTopStepOneOperateType(BffJudgeTopStepOneOperateTypeReqDto reqDto) {


        JudgeTopStepOneOperateTypeRespDto judgeTopStepOneOperateTypeRespDto_1 = null;
//步骤0: D3-13判断高层第1步操作类型 - judgeTopStepOneOperateType
        JudgeTopStepOneOperateTypeRespDto judgeTopStepOneOperateTypeRespDto = null;
        JudgeTopStepOneOperateTypeReqDto judgeTopStepOneOperateTypeReqDto = new JudgeTopStepOneOperateTypeReqDto();
        if (reqDto != null) {
            judgeTopStepOneOperateTypeReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:339477_1
            judgeTopStepOneOperateTypeReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:339478_1
        }

        /*D3-13判断高层第1步操作类型[4404]   */
        Assert.isNull(judgeTopStepOneOperateTypeReqDto.getTargetId(), "B3-13判断高层第1步可进入的房间(管理)-D3-13判断高层第1步操作类型-目标ID不能为空", false);
        Assert.isNull(judgeTopStepOneOperateTypeReqDto.getEvaluationTemplateId(), "B3-13判断高层第1步可进入的房间(管理)-D3-13判断高层第1步操作类型-归属评价模板ID不能为空", false);
        judgeTopStepOneOperateTypeRespDto = fwAppOffStateClient.judgeTopStepOneOperateType(judgeTopStepOneOperateTypeReqDto).getData();


        judgeTopStepOneOperateTypeRespDto_1 = judgeTopStepOneOperateTypeRespDto;

        BffJudgeTopStepOneOperateTypeRespDto retData = new BffJudgeTopStepOneOperateTypeRespDto();
        if (judgeTopStepOneOperateTypeRespDto_1 != null) {
            retData.setTargetTaskDivRoom(judgeTopStepOneOperateTypeRespDto_1.getTargetTaskDivRoom());//SimpleFieldAssign//sourceId:379973_1
            retData.setDeptTargetWeightSetRoom(judgeTopStepOneOperateTypeRespDto_1.getDeptTargetWeightSetRoom());//SimpleFieldAssign//sourceId:339488_1
            retData.setPalnCompileAchieveRoom(judgeTopStepOneOperateTypeRespDto_1.getPalnCompileAchieveRoom());//SimpleFieldAssign//sourceId:339489_1
        }


        return retData;
    }

    /**
     * B3-11查询高层目标检查项状态(管理)[2928]
     * gen by moon at 9/15/2022, 12:26:47 AM
     */
    @Trace(operationName = "B3-11查询高层目标检查项状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryTopTargetCheckItemStatusDetailRespDto queryTopTargetCheckItemStatusDetail(BffQueryTopTargetCheckItemStatusDetailReqDto reqDto) {


        QueryBizAppCheckItemStatDetailRespDto queryBizAppCheckItemStatDetailRespDto_1 = null;
//步骤0: D3-11查业务应用校验项状态详情 - queryBizAppCheckItemStatDetail
        QueryBizAppCheckItemStatDetailRespDto queryBizAppCheckItemStatDetailRespDto = null;
        QueryBizAppCheckItemStatDetailReqDto queryBizAppCheckItemStatDetailReqDto = new QueryBizAppCheckItemStatDetailReqDto();
        queryBizAppCheckItemStatDetailReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:94423_1
        if (reqDto != null) {
            queryBizAppCheckItemStatDetailReqDto.setEntityId(reqDto.getEntityId());//sourceId:94422_1
            queryBizAppCheckItemStatDetailReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:94421_1
        }

        /*D3-11查业务应用校验项状态详情[2930]   */
        Assert.isNull(queryBizAppCheckItemStatDetailReqDto.getEntityId(), "B3-11查询高层目标检查项状态(管理)-D3-11查业务应用校验项状态详情-内容对象实例ID不能为空", false);
        Assert.isNull(queryBizAppCheckItemStatDetailReqDto.getObjectTypeCode(), "B3-11查询高层目标检查项状态(管理)-D3-11查业务应用校验项状态详情-内容对象类型编码不能为空", false);
        Assert.isNull(queryBizAppCheckItemStatDetailReqDto.getCheckItemCode(), "B3-11查询高层目标检查项状态(管理)-D3-11查业务应用校验项状态详情-检查项标识不能为空", false);
        queryBizAppCheckItemStatDetailRespDto = fwAppOffStateClient.queryBizAppCheckItemStatDetail(queryBizAppCheckItemStatDetailReqDto).getData();


        queryBizAppCheckItemStatDetailRespDto_1 = queryBizAppCheckItemStatDetailRespDto;

        BffQueryTopTargetCheckItemStatusDetailRespDto retData = new BffQueryTopTargetCheckItemStatusDetailRespDto();
        if (queryBizAppCheckItemStatDetailRespDto_1 != null) {
            retData.setStatusCheckItemId(queryBizAppCheckItemStatDetailRespDto_1.getStatusCheckItemId());//sourceId:94427_1
            retData.setIsComplete(queryBizAppCheckItemStatDetailRespDto_1.getIsComplete());//sourceId:94429_1
        }


        return retData;
    }

    /**
     * B3-11查询目标内容仪表盘列表(管理)[3960]
     * gen by moon at 10/8/2022, 3:10:13 AM
     */
    @Trace(operationName = "B3-11查询目标内容仪表盘列表(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryTargetContCheckItemPanelListRespDto queryTargetContCheckItemPanelList(BffQueryTargetContCheckItemPanelListReqDto reqDto) {


        QueryTargetContCheckItemPanelListRespDto queryTargetContCheckItemPanelListRespDto_1 = null;
        BatchQueryCheckItemRespDto batchQueryCheckItemRespDto_1 = null;
//步骤0: D3-3查询目标内容仪表盘列表 - queryTargetContCheckItemPanelList
        QueryTargetContCheckItemPanelListRespDto queryTargetContCheckItemPanelListRespDto = null;
        QueryTargetContCheckItemPanelListReqDto queryTargetContCheckItemPanelListReqDto = new QueryTargetContCheckItemPanelListReqDto();
        if (reqDto != null) {
            queryTargetContCheckItemPanelListReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//SimpleFieldAssign//sourceId:203985_1
            queryTargetContCheckItemPanelListReqDto.setCheckObjectTypeCode(reqDto.getCheckObjectTypeCode());//SimpleFieldAssign//sourceId:203986_1
        }

        /*D3-3查询目标内容仪表盘列表[3961]   */
        Assert.isNull(queryTargetContCheckItemPanelListReqDto.getCheckObjectTypeId(), "B3-11查询目标内容仪表盘列表(管理)-D3-3查询目标内容仪表盘列表-检查内容对象ID 不能为空", false);
        Assert.isNull(queryTargetContCheckItemPanelListReqDto.getCheckObjectTypeCode(), "B3-11查询目标内容仪表盘列表(管理)-D3-3查询目标内容仪表盘列表-检查内容对象类型编码不能为空", false);
        queryTargetContCheckItemPanelListRespDto = fwAppOffStateClient.queryTargetContCheckItemPanelList(queryTargetContCheckItemPanelListReqDto).getData();


        queryTargetContCheckItemPanelListRespDto_1 = queryTargetContCheckItemPanelListRespDto;

//步骤1: D3-11批量查询检查项 - batchQueryCheckItem
        BatchQueryCheckItemRespDto batchQueryCheckItemRespDto = null;
        if (queryTargetContCheckItemPanelListRespDto != null) {
            BatchQueryCheckItemReqDto batchQueryCheckItemReqDto = new BatchQueryCheckItemReqDto();
            batchQueryCheckItemReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:203998_1
            if (queryTargetContCheckItemPanelListRespDto != null) {
                batchQueryCheckItemReqDto.setCheckItemList(queryTargetContCheckItemPanelListRespDto.getCheckItemPanelList().stream().map(item -> item.getCheckItemCode())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:203995_1
            }

            /*D3-11批量查询检查项[3978]   */
            Assert.isNull(batchQueryCheckItemReqDto.getSubjectLifeCycle(), "B3-11查询目标内容仪表盘列表(管理)-D3-11批量查询检查项-主体生命周期不能为空", false);
            batchQueryCheckItemRespDto = fwAppOffStateClient.batchQueryCheckItem(batchQueryCheckItemReqDto).getData();


            batchQueryCheckItemRespDto_1 = batchQueryCheckItemRespDto;
        }

        BffQueryTargetContCheckItemPanelListRespDto retData = new BffQueryTargetContCheckItemPanelListRespDto();
        //sourceId:204008_1


        return retData;
    }

    /**
     * B3-11查询中层目标安排检查项完成情况(管理)[3739]
     * gen by moon at 9/23/2022, 5:58:39 AM
     */
    @Trace(operationName = "B3-11查询中层目标安排检查项完成情况(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryMidExecuteTargetArrangeStateDetailRespDto queryMidExecuteTargetArrangeStateDetail(BffQueryMidExecuteTargetArrangeStateDetailReqDto reqDto) {


        BatchQueryMidExecuteTargetCheckItemRespDto batchQueryMidExecuteTargetCheckItemRespDto_1 = null;
//步骤0: D3-11查询部门目标任务书ID列表(公共) - queryDeptTargetTaskBookIdListCom
        QueryDeptTargetTaskBookIdListComRespDto queryDeptTargetTaskBookIdListComRespDto = null;
        QueryDeptTargetTaskBookIdListComReqDto queryDeptTargetTaskBookIdListComReqDto = new QueryDeptTargetTaskBookIdListComReqDto();
        if (reqDto != null) {
//      queryDeptTargetTaskBookIdListComReqDto.setTargetId(reqDto.getTargetId());//sourceId:217250_1
        }

        /*D3-11查询部门目标任务书ID列表(公共)[4026]   */
//    Assert.isNull(queryDeptTargetTaskBookIdListComReqDto.getTargetId(),"B3-11查询中层目标安排检查项完成情况(管理)-D3-11查询部门目标任务书ID列表(公共)-冗余目标ID不能为空",false);
        queryDeptTargetTaskBookIdListComRespDto = fwAppTargetCycleClient.queryDeptTargetTaskBookIdListCom(queryDeptTargetTaskBookIdListComReqDto).getData();


//步骤1: D3-11批量查询中层执行目标安排检查项 - batchQueryMidExecuteTargetCheckItem
        BatchQueryMidExecuteTargetCheckItemRespDto batchQueryMidExecuteTargetCheckItemRespDto = null;
        if (queryDeptTargetTaskBookIdListComRespDto != null) {
            BatchQueryMidExecuteTargetCheckItemReqDto batchQueryMidExecuteTargetCheckItemReqDto = new BatchQueryMidExecuteTargetCheckItemReqDto();
            if (queryDeptTargetTaskBookIdListComRespDto != null) {
                batchQueryMidExecuteTargetCheckItemReqDto.setBizAppCheckItemStatList(queryDeptTargetTaskBookIdListComRespDto.getDeptTargetTaskBookIdList().stream().map(item -> item.getEvaObjTargetCycleId())
                        .collect(Collectors.toList()));//sourceId:217466_1
            }
            if (reqDto != null) {
                batchQueryMidExecuteTargetCheckItemReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:341399_1
            }

            /*D3-11批量查询中层执行目标安排检查项[4027]   */
            Assert.isNull(batchQueryMidExecuteTargetCheckItemReqDto.getCheckItemCode(), "B3-11查询中层目标安排检查项完成情况(管理)-D3-11批量查询中层执行目标安排检查项-检查项标识不能为空", false);
            batchQueryMidExecuteTargetCheckItemRespDto = fwAppOffStateClient.batchQueryMidExecuteTargetCheckItem(batchQueryMidExecuteTargetCheckItemReqDto).getData();


            batchQueryMidExecuteTargetCheckItemRespDto_1 = batchQueryMidExecuteTargetCheckItemRespDto;
        }

        BffQueryMidExecuteTargetArrangeStateDetailRespDto retData = new BffQueryMidExecuteTargetArrangeStateDetailRespDto();
        if (batchQueryMidExecuteTargetCheckItemRespDto_1 != null) {
            retData.setEvaObjTargetCycleList(batchQueryMidExecuteTargetCheckItemRespDto_1.getBizAppCheckItemStatList().stream().map(item -> BeanUtil.toBean(item, BffEvaObjTargetCycleDto.class)).collect(Collectors.toList()));//sourceId:329177_1
            retData.setOutputNum(batchQueryMidExecuteTargetCheckItemRespDto_1.getOutputNum());//sourceId:217471_1
        }


        return retData;
    }

    /**
     * B3-11设中层完成安排(管理)[3039]
     * gen by moon at 10/24/2023, 3:33:12 AM
     */
    @Trace(operationName = "B3-11设中层完成安排(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffCompleteMidSetAchieveRespDto completeMidSetAchieve(BffCompleteMidSetAchieveReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D3执行中层导向步骤房间  51052
        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
        ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
        implementTopMidBasicGuideStepRoomReqDto.setAchieveArrange("1");//CUSTOM_CONVENTION//sourceId:1203695_1_51052
        implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("MID");//sourceId:1203696_1_51052
        if (reqDto != null) {
            implementTopMidBasicGuideStepRoomReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1203697_1_51052
            implementTopMidBasicGuideStepRoomReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203698_1_51052
        }

        /*D3执行中层导向步骤房间[7600]   */
        Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getAchieveArrange(), "B3-11设中层完成安排(管理)-D3执行中层导向步骤房间-完成安排不能为空", false);
        Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11设中层完成安排(管理)-D3执行中层导向步骤房间-高/中/基层操作场景不能为空", false);
        Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptId(), "B3-11设中层完成安排(管理)-D3执行中层导向步骤房间-一级部门ID不能为空", false);
        Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEvaluationTemplateId(), "B3-11设中层完成安排(管理)-D3执行中层导向步骤房间-冗余评价模板ID不能为空", false);
        implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
        if ((implementTopMidBasicGuideStepRoomRespDto != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null)) {
            //if(D3执行中层导向步骤房间.进入步骤房间值 值不等于空 )  51053

            UpdateMidSetAchieveRespDto updateMidSetAchieveRespDto = null;
            UpdateMidSetAchieveReqDto updateMidSetAchieveReqDto = new UpdateMidSetAchieveReqDto();
            if (reqDto != null) {
                updateMidSetAchieveReqDto.setTargetObjList(reqDto.getTargetObjList());//list-field-assign//sourceId:202508_1_51054
                updateMidSetAchieveReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:210263_1_51054
                updateMidSetAchieveReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:210265_1_51054
                updateMidSetAchieveReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334835_1_51054
                updateMidSetAchieveReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:210266_1_51054
            }

            /*D3-11修改中层设置完成[3747]   */
            Assert.isNull(updateMidSetAchieveReqDto.getDeptId(), "B3-11设中层完成安排(管理)-D3-11修改中层设置完成-部门ID不能为空", false);
            Assert.isNull(updateMidSetAchieveReqDto.getTargetId(), "B3-11设中层完成安排(管理)-D3-11修改中层设置完成-冗余目标ID不能为空", false);
            Assert.isNull(updateMidSetAchieveReqDto.getEvaluationTemplateId(), "B3-11设中层完成安排(管理)-D3-11修改中层设置完成-冗余评价模板ID不能为空", false);
            Assert.isNull(updateMidSetAchieveReqDto.getBatchCode(), "B3-11设中层完成安排(管理)-D3-11修改中层设置完成-批次标识不能为空", false);
            updateMidSetAchieveRespDto = fwAppOffStateClient.updateMidSetAchieve(updateMidSetAchieveReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        BffCompleteMidSetAchieveRespDto retData = new BffCompleteMidSetAchieveRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203699_1
        }


        return retData;
    }

    /**
     * B3-11查目标分类检查仪表盘列表(管理)[2715]
     * gen by moon at 10/20/2022, 10:06:19 AM
     */
    @Trace(operationName = "B3-11查目标分类检查仪表盘列表(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryTargetCatCheckItemPanelListRespDto queryTargetCatCheckItemPanelList(BffQueryTargetCatCheckItemPanelListReqDto reqDto) {


        QueryCheckItemPanelListRespDto queryCheckItemPanelListRespDto_1 = null;
        BatchQueryCheckItemRespDto batchQueryCheckItemRespDto_1 = null;
        JudgeShoppingTrolleySaveTermRespDto judgeShoppingTrolleySaveTermRespDto_1 = null;
//步骤0: D3-11查检查仪表盘列表 - queryCheckItemPanelList
        QueryCheckItemPanelListRespDto queryCheckItemPanelListRespDto = null;
        QueryCheckItemPanelListReqDto queryCheckItemPanelListReqDto = new QueryCheckItemPanelListReqDto();
        queryCheckItemPanelListReqDto.setCheckObjectTypeCode("OMS_TARGET_CATEGORY");//sourceId:84779_1
        if (reqDto != null) {
            queryCheckItemPanelListReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//SimpleFieldAssign//sourceId:84710_1
        }

        /*D3-11查检查仪表盘列表[2716]   */
        Assert.isNull(queryCheckItemPanelListReqDto.getCheckObjectTypeId(), "B3-11查目标分类检查仪表盘列表(管理)-D3-11查检查仪表盘列表-检查内容对象ID 不能为空", false);
        Assert.isNull(queryCheckItemPanelListReqDto.getCheckObjectTypeCode(), "B3-11查目标分类检查仪表盘列表(管理)-D3-11查检查仪表盘列表-检查内容对象类型编码不能为空", false);
        queryCheckItemPanelListRespDto = fwAppOffStateClient.queryCheckItemPanelList(queryCheckItemPanelListReqDto).getData();


        queryCheckItemPanelListRespDto_1 = queryCheckItemPanelListRespDto;

//步骤1: D3-11批量查询检查项 - batchQueryCheckItem
        BatchQueryCheckItemRespDto batchQueryCheckItemRespDto = null;
        if (queryCheckItemPanelListRespDto != null) {
            BatchQueryCheckItemReqDto batchQueryCheckItemReqDto = new BatchQueryCheckItemReqDto();
            batchQueryCheckItemReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:218080_1
            if (queryCheckItemPanelListRespDto != null) {
                batchQueryCheckItemReqDto.setCheckItemList(queryCheckItemPanelListRespDto.getTargetDashboardCompletionStatusList().stream().map(item -> item.getCheckItemCode())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:218079_1
            }

            /*D3-11批量查询检查项[3978]   */
            Assert.isNull(batchQueryCheckItemReqDto.getSubjectLifeCycle(), "B3-11查目标分类检查仪表盘列表(管理)-D3-11批量查询检查项-主体生命周期不能为空", false);
            batchQueryCheckItemRespDto = fwAppOffStateClient.batchQueryCheckItem(batchQueryCheckItemReqDto).getData();


            batchQueryCheckItemRespDto_1 = batchQueryCheckItemRespDto;
        }

//步骤2: D3-11判断购物车确认保存操作条件 - judgeShoppingTrolleySaveTerm
        JudgeShoppingTrolleySaveTermRespDto judgeShoppingTrolleySaveTermRespDto = null;
        JudgeShoppingTrolleySaveTermReqDto judgeShoppingTrolleySaveTermReqDto = new JudgeShoppingTrolleySaveTermReqDto();
        judgeShoppingTrolleySaveTermReqDto.setObjectTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:221686_1
        if (reqDto != null) {
            judgeShoppingTrolleySaveTermReqDto.setBizAppCheckItemStatList(reqDto.getTargetObjList());//list-field-assign//sourceId:221685_1
        }

        /*D3-11判断购物车确认保存操作条件[4041]   */
        Assert.isNull(judgeShoppingTrolleySaveTermReqDto.getObjectTypeCode(), "B3-11查目标分类检查仪表盘列表(管理)-D3-11判断购物车确认保存操作条件-内容对象类型编码不能为空", false);
        judgeShoppingTrolleySaveTermRespDto = fwAppOffStateClient.judgeShoppingTrolleySaveTerm(judgeShoppingTrolleySaveTermReqDto).getData();


        judgeShoppingTrolleySaveTermRespDto_1 = judgeShoppingTrolleySaveTermRespDto;

        BffQueryTargetCatCheckItemPanelListRespDto retData = new BffQueryTargetCatCheckItemPanelListRespDto();
        //数据集融合  MoreListToOneSource
        if (queryCheckItemPanelListRespDto_1 != null && !CollectionUtil.isEmpty(queryCheckItemPanelListRespDto_1.getTargetDashboardCompletionStatusList())) {
            for (TargetDashboardCompletionStatusDto targetDashboardCompletionStatusDto : queryCheckItemPanelListRespDto_1.getTargetDashboardCompletionStatusList()) {
                BffCheckItemPanelDto retElm = new BffCheckItemPanelDto();
                if (queryCheckItemPanelListRespDto_1 != null) {
                    retElm.setCheckItemPanelUpdateId(targetDashboardCompletionStatusDto.getCheckItemPanelUpdateId());//SimpleFieldAssign//sourceId:109153_2
                    retElm.setCheckItemCode(targetDashboardCompletionStatusDto.getCheckItemCode());//SimpleFieldAssign//sourceId:109154_2
                    retElm.setTargetValue(targetDashboardCompletionStatusDto.getTargetValue());//SimpleFieldAssign//sourceId:109155_2
                    retElm.setActualValue(targetDashboardCompletionStatusDto.getActualValue());//SimpleFieldAssign//sourceId:109156_2
                    retElm.setIsComplete(targetDashboardCompletionStatusDto.getIsComplete());//SimpleFieldAssign//sourceId:109157_2
                }
                retData.getCheckItemPanelList().add(retElm);
                if (batchQueryCheckItemRespDto_1 != null) {
                    for (CheckItemListDto checkItemListDto : batchQueryCheckItemRespDto_1.getCheckItemList()) {
                        if (checkItemListDto.getCheckItemId().equals(targetDashboardCompletionStatusDto.getCheckItemId())) {
                            if (batchQueryCheckItemRespDto_1 != null) {
                                retElm.setCheckItemId(checkItemListDto.getCheckItemId());//SimpleFieldAssign//sourceId:108979_2
                                retElm.setCheckItemName(checkItemListDto.getCheckItemName());//SimpleFieldAssign//sourceId:82275_2
                            }
                        }
                    }
                }

            }
        }//sourceId:84713_1
        if (judgeShoppingTrolleySaveTermRespDto_1 != null) {
            retData.setOutputNum(judgeShoppingTrolleySaveTermRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:221690_1
        }
        if (queryCheckItemPanelListRespDto_1 != null) {
            retData.setMolecule(queryCheckItemPanelListRespDto_1.getMolecule());//SimpleFieldAssign//sourceId:384233_1
            retData.setDenominator(queryCheckItemPanelListRespDto_1.getDenominator());//SimpleFieldAssign//sourceId:384234_1
        }


        return retData;
    }

    /**
     * B3-11查询指标仪表盘列表(管理)[4085]
     * gen by moon at 10/20/2022, 10:06:21 AM
     */
    @Trace(operationName = "B3-11查询指标仪表盘列表(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryTargetObjCheckItemPanelListRespDto queryTargetObjCheckItemPanelList(BffQueryTargetObjCheckItemPanelListReqDto reqDto) {


        QueryCheckItemPanelListRespDto queryCheckItemPanelListRespDto_1 = null;
        BatchQueryCheckItemRespDto batchQueryCheckItemRespDto_1 = null;
        JudgeShoppingTrolleySaveTermRespDto judgeShoppingTrolleySaveTermRespDto_1 = null;
//步骤0: D3-11查检查仪表盘列表 - queryCheckItemPanelList
        QueryCheckItemPanelListRespDto queryCheckItemPanelListRespDto = null;
        QueryCheckItemPanelListReqDto queryCheckItemPanelListReqDto = new QueryCheckItemPanelListReqDto();
        queryCheckItemPanelListReqDto.setCheckObjectTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:221848_1
        if (reqDto != null) {
            queryCheckItemPanelListReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//SimpleFieldAssign//sourceId:221846_1
        }

        /*D3-11查检查仪表盘列表[2716]   */
        Assert.isNull(queryCheckItemPanelListReqDto.getCheckObjectTypeId(), "B3-11查询指标仪表盘列表(管理)-D3-11查检查仪表盘列表-检查内容对象ID 不能为空", false);
        Assert.isNull(queryCheckItemPanelListReqDto.getCheckObjectTypeCode(), "B3-11查询指标仪表盘列表(管理)-D3-11查检查仪表盘列表-检查内容对象类型编码不能为空", false);
        queryCheckItemPanelListRespDto = fwAppOffStateClient.queryCheckItemPanelList(queryCheckItemPanelListReqDto).getData();


        queryCheckItemPanelListRespDto_1 = queryCheckItemPanelListRespDto;

//步骤1: D3-11批量查询检查项 - batchQueryCheckItem
        BatchQueryCheckItemRespDto batchQueryCheckItemRespDto = null;
        if (queryCheckItemPanelListRespDto != null) {
            BatchQueryCheckItemReqDto batchQueryCheckItemReqDto = new BatchQueryCheckItemReqDto();
            batchQueryCheckItemReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:221850_1
            if (queryCheckItemPanelListRespDto != null) {
                batchQueryCheckItemReqDto.setCheckItemList(queryCheckItemPanelListRespDto.getTargetDashboardCompletionStatusList().stream().map(item -> item.getCheckItemCode())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:221849_1
            }

            /*D3-11批量查询检查项[3978]   */
            Assert.isNull(batchQueryCheckItemReqDto.getSubjectLifeCycle(), "B3-11查询指标仪表盘列表(管理)-D3-11批量查询检查项-主体生命周期不能为空", false);
            batchQueryCheckItemRespDto = fwAppOffStateClient.batchQueryCheckItem(batchQueryCheckItemReqDto).getData();


            batchQueryCheckItemRespDto_1 = batchQueryCheckItemRespDto;
        }

//步骤2: D3-11判断购物车确认保存操作条件 - judgeShoppingTrolleySaveTerm
        JudgeShoppingTrolleySaveTermRespDto judgeShoppingTrolleySaveTermRespDto = null;
        JudgeShoppingTrolleySaveTermReqDto judgeShoppingTrolleySaveTermReqDto = new JudgeShoppingTrolleySaveTermReqDto();
        judgeShoppingTrolleySaveTermReqDto.setObjectTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:221853_1
        if (reqDto != null) {
            judgeShoppingTrolleySaveTermReqDto.setBizAppCheckItemStatList(reqDto.getTargetObjList());//list-field-assign//sourceId:221852_1
        }

        /*D3-11判断购物车确认保存操作条件[4041]   */
        Assert.isNull(judgeShoppingTrolleySaveTermReqDto.getObjectTypeCode(), "B3-11查询指标仪表盘列表(管理)-D3-11判断购物车确认保存操作条件-内容对象类型编码不能为空", false);
        judgeShoppingTrolleySaveTermRespDto = fwAppOffStateClient.judgeShoppingTrolleySaveTerm(judgeShoppingTrolleySaveTermReqDto).getData();


        judgeShoppingTrolleySaveTermRespDto_1 = judgeShoppingTrolleySaveTermRespDto;

        BffQueryTargetObjCheckItemPanelListRespDto retData = new BffQueryTargetObjCheckItemPanelListRespDto();
        //数据集融合  MoreListToOneSource
        if (queryCheckItemPanelListRespDto_1 != null && !CollectionUtil.isEmpty(queryCheckItemPanelListRespDto_1.getTargetDashboardCompletionStatusList())) {
            for (TargetDashboardCompletionStatusDto targetDashboardCompletionStatusDto : queryCheckItemPanelListRespDto_1.getTargetDashboardCompletionStatusList()) {
                BffCheckItemPanelDto retElm = new BffCheckItemPanelDto();
                if (queryCheckItemPanelListRespDto_1 != null) {
                    retElm.setCheckItemPanelUpdateId(targetDashboardCompletionStatusDto.getCheckItemPanelUpdateId());//SimpleFieldAssign//sourceId:109158_2
                    retElm.setCheckItemCode(targetDashboardCompletionStatusDto.getCheckItemCode());//SimpleFieldAssign//sourceId:109159_2
                    retElm.setTargetValue(targetDashboardCompletionStatusDto.getTargetValue());//SimpleFieldAssign//sourceId:109160_2
                    retElm.setActualValue(targetDashboardCompletionStatusDto.getActualValue());//SimpleFieldAssign//sourceId:109161_2
                    retElm.setIsComplete(targetDashboardCompletionStatusDto.getIsComplete());//SimpleFieldAssign//sourceId:109162_2
                }
                retData.getCheckItemPanelList().add(retElm);
                if (batchQueryCheckItemRespDto_1 != null) {
                    for (CheckItemListDto checkItemListDto : batchQueryCheckItemRespDto_1.getCheckItemList()) {
                        if (checkItemListDto.getCheckItemId().equals(targetDashboardCompletionStatusDto.getCheckItemId())) {
                            if (batchQueryCheckItemRespDto_1 != null) {
                                retElm.setCheckItemId(checkItemListDto.getCheckItemId());//SimpleFieldAssign//sourceId:108978_2
                                retElm.setCheckItemName(checkItemListDto.getCheckItemName());//SimpleFieldAssign//sourceId:108957_2
                            }
                        }
                    }
                }

            }
        }//sourceId:221857_1
        if (judgeShoppingTrolleySaveTermRespDto_1 != null) {
            retData.setOutputNum(judgeShoppingTrolleySaveTermRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:221858_1
        }
        if (queryCheckItemPanelListRespDto_1 != null) {
            retData.setMolecule(queryCheckItemPanelListRespDto_1.getMolecule());//SimpleFieldAssign//sourceId:384237_1
            retData.setDenominator(queryCheckItemPanelListRespDto_1.getDenominator());//SimpleFieldAssign//sourceId:384238_1
        }


        return retData;
    }

    /**
     * B3-11中层修改目标安排(管理)[3048]
     * gen by moon at 2/17/2024, 10:58:59 PM
     */
    @Trace(operationName = "B3-11中层修改目标安排(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateMidEditRespDto updateMidEdit(BffUpdateMidEditReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2执行上并发中层步骤变更锁(公共)  61174
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540293_1_61174
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540294_1_61174
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1540296_1_61174
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540297_1_61174
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540298_1_61174
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540295_1_61174
        }

        /*D2执行上并发中层步骤变更锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3-11中层修改目标安排(管理)-D2执行上并发中层步骤变更锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61175

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setEditTargetArrange("1");//CUSTOM_CONVENTION//sourceId:1203751_1_61176
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("MID");//sourceId:1203752_1_61176
            if (reqDto != null) {
                implementTopMidBasicGuideStepRoomReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1203753_1_61176
                implementTopMidBasicGuideStepRoomReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203754_1_61176
            }

            /*D3执行中层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEditTargetArrange(), "B3-11中层修改目标安排(管理)-D3执行中层导向步骤房间-修改目标安排不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11中层修改目标安排(管理)-D3执行中层导向步骤房间-高/中/基层操作场景不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptId(), "B3-11中层修改目标安排(管理)-D3执行中层导向步骤房间-一级部门ID不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEvaluationTemplateId(), "B3-11中层修改目标安排(管理)-D3执行中层导向步骤房间-冗余评价模板ID不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("MID");//sourceId:1540303_1_61177
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540299_1_61177
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540300_1_61177
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1540302_1_61177
                }

                /*D3执行高中基层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3-11中层修改目标安排(管理)-D3执行高中基层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3-11中层修改目标安排(管理)-D3执行高中基层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3-11中层修改目标安排(管理)-D3执行高中基层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3-11中层修改目标安排(管理)-D3执行高中基层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE") && implementTopMidBasicGuideStepRoomRespDto != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("TARGET_TASK_DIV_ROOM"))) {
                //if((D3执行高中基层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 目标任务分工房间))  61178

                UpdateMidEditRespDto updateMidEditRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    UpdateMidEditReqDto updateMidEditReqDto = new UpdateMidEditReqDto();
                    if (reqDto != null) {
                        updateMidEditReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:329981_1_61179
                        updateMidEditReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:856684_1_61179
                        updateMidEditReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334829_1_61179
                        updateMidEditReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:856685_1_61179
                        updateMidEditReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856686_1_61179
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        updateMidEditReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:340731_1_61179
                    }

                    /*D3-11中层修改安排[4553]   */
                    Assert.isNull(updateMidEditReqDto.getDeptId(), "B3-11中层修改目标安排(管理)-D3-11中层修改安排-部门ID不能为空", false);
                    Assert.isNull(updateMidEditReqDto.getDeptTargetTaskBookId(), "B3-11中层修改目标安排(管理)-D3-11中层修改安排-部门目标任务书ID不能为空", false);
                    Assert.isNull(updateMidEditReqDto.getEvaluationTemplateId(), "B3-11中层修改目标安排(管理)-D3-11中层修改安排-冗余评价模板ID不能为空", false);
                    Assert.isNull(updateMidEditReqDto.getStepRoomValue(), "B3-11中层修改目标安排(管理)-D3-11中层修改安排-进入步骤房间值不能为空", false);
                    Assert.isNull(updateMidEditReqDto.getBatchCode(), "B3-11中层修改目标安排(管理)-D3-11中层修改安排-批次标识不能为空", false);
                    Assert.isNull(updateMidEditReqDto.getBatchCurrentStatus(), "B3-11中层修改目标安排(管理)-D3-11中层修改安排-批次现状不能为空", false);
                    updateMidEditRespDto = fwAppOffStateClient.updateMidEdit(updateMidEditReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540304_1_61180
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540305_1_61180
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540307_1_61180
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540306_1_61180
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE") && implementTopMidBasicGuideStepRoomRespDto != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("EXECUTE_TARGET_ARRANGE_ROOM"))) {
                //elseif((D3执行高中基层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 执行目标安排房间))  61181

                ImplementMidReturnSecondStepComRespDto implementMidReturnSecondStepComRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    ImplementMidReturnSecondStepComReqDto implementMidReturnSecondStepComReqDto = new ImplementMidReturnSecondStepComReqDto();
                    implementMidReturnSecondStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1113305_1_61182
                    implementMidReturnSecondStepComReqDto.setBackMsgSendType("UN_SEND_MSG");//sourceId:1550939_1_61182
                    if (reqDto != null) {
                        implementMidReturnSecondStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1052627_1_61182
                        implementMidReturnSecondStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1052628_1_61182
                        implementMidReturnSecondStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1052629_1_61182
                        implementMidReturnSecondStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1052631_1_61182
                        implementMidReturnSecondStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1052633_1_61182
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        implementMidReturnSecondStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1052630_1_61182
                    }

                    /*D3执行中层返回第二步(公共)[6330]   */
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getDeptId(), "B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-部门ID不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getDeptTargetTaskBookId(), "B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-部门目标任务书ID不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getEvaluationTemplateId(), "B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getStepRoomValue(), "B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-进入步骤房间值不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getBatchCode(), "B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-批次标识不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getBatchCurrentStatus(), "B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-批次现状不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getUseTypeCode(), "B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-用途类型编码不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getBackMsgSendType(), "B3-11中层修改目标安排(管理)-D3执行中层返回第二步(公共)-回退消息发送类型不能为空", false);
                    implementMidReturnSecondStepComRespDto = fwAppOffStateClient.implementMidReturnSecondStepCom(implementMidReturnSecondStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_3 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_2 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_2.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540304_1_61183
                implementConcBhvThemeLockComComReqDto_2.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540305_1_61183
                implementConcBhvThemeLockComComReqDto_2.setWhetherUnlockBulk("FALSE");//sourceId:1540307_1_61183
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_2.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540306_1_61183
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getPreventConcurrentLockingUnlocking(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getBehaviorThemeLockCode(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getCommPrimaryKey(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getWhetherUnlockBulk(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_3 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE") && implementTopMidBasicGuideStepRoomRespDto != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("LEAD_TARGET_ARRANGE_ROOM"))) {
                //elseif((D3执行高中基层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 牵头目标安排房间))  61184

                ImplementMidReturnFirstStepComRespDto implementMidReturnFirstStepComRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    ImplementMidReturnFirstStepComReqDto implementMidReturnFirstStepComReqDto = new ImplementMidReturnFirstStepComReqDto();
                    implementMidReturnFirstStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1113306_1_61185
                    implementMidReturnFirstStepComReqDto.setBackMsgSendType("UN_SEND_MSG");//sourceId:1550942_1_61185
                    if (reqDto != null) {
                        implementMidReturnFirstStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1052640_1_61185
                        implementMidReturnFirstStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1052636_1_61185
                        implementMidReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1052637_1_61185
                        implementMidReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1052639_1_61185
                        implementMidReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1052642_1_61185
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        implementMidReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1052638_1_61185
                    }

                    /*D3执行中层返回第一步(公共)[3748]   */
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptId(), "B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-部门ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptTargetTaskBookId(), "B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-部门目标任务书ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getEvaluationTemplateId(), "B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getStepRoomValue(), "B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-进入步骤房间值不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCode(), "B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-批次标识不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCurrentStatus(), "B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-批次现状不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getUseTypeCode(), "B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-用途类型编码不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getBackMsgSendType(), "B3-11中层修改目标安排(管理)-D3执行中层返回第一步(公共)-回退消息发送类型不能为空", false);
                    implementMidReturnFirstStepComRespDto = fwAppOffStateClient.implementMidReturnFirstStepCom(implementMidReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_4 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_3 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_3.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540304_1_61186
                implementConcBhvThemeLockComComReqDto_3.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540305_1_61186
                implementConcBhvThemeLockComComReqDto_3.setWhetherUnlockBulk("FALSE");//sourceId:1540307_1_61186
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_3.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540306_1_61186
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_3.getPreventConcurrentLockingUnlocking(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_3.getBehaviorThemeLockCode(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_3.getCommPrimaryKey(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_3.getWhetherUnlockBulk(), "B3-11中层修改目标安排(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_4 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行高中基层当前步骤判断(公共).是否相等 等于 是)  61187

//异常结束 61188
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61189

//异常结束 61190
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffUpdateMidEditRespDto retData = new BffUpdateMidEditRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203778_1
        }


        return retData;
    }

    /**
     * B3-11基层修改目标安排(管理)[3061]
     * gen by moon at 10/24/2023, 3:33:43 AM
     */
    @Trace(operationName = "B3-11基层修改目标安排(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateGrootsEditRespDto updateGrootsEdit(BffUpdateGrootsEditReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D3执行高中基层导向步骤房间  51049
        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
        ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
        implementTopMidBasicGuideStepRoomReqDto.setEditTargetArrange("1");//CUSTOM_CONVENTION//sourceId:1203674_1_51049
        implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("BASIC");//sourceId:1203675_1_51049

        /*D3执行高中基层导向步骤房间[7600]   */
        Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEditTargetArrange(), "B3-11基层修改目标安排(管理)-D3执行高中基层导向步骤房间-修改目标安排不能为空", false);
        Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11基层修改目标安排(管理)-D3执行高中基层导向步骤房间-高/中/基层操作场景不能为空", false);
        implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
        if ((implementTopMidBasicGuideStepRoomRespDto != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null)) {
            //if(D3执行高中基层导向步骤房间.进入步骤房间值 值不等于空 )  51050

            UpdateGrootsEditRespDto updateGrootsEditRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                UpdateGrootsEditReqDto updateGrootsEditReqDto = new UpdateGrootsEditReqDto();
                if (reqDto != null) {
                    updateGrootsEditReqDto.setDeptOkrTargetId(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:856701_1_51051
                    updateGrootsEditReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:335443_1_51051
                    updateGrootsEditReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:856702_1_51051
                    updateGrootsEditReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856703_1_51051
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    updateGrootsEditReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:340918_1_51051
                }

                /*D3-11基层修改安排[4618]   */
                Assert.isNull(updateGrootsEditReqDto.getDeptOkrTargetId(), "B3-11基层修改目标安排(管理)-D3-11基层修改安排-部门OKR目标ID不能为空", false);
                Assert.isNull(updateGrootsEditReqDto.getTargetId(), "B3-11基层修改目标安排(管理)-D3-11基层修改安排-冗余目标ID不能为空", false);
                Assert.isNull(updateGrootsEditReqDto.getStepRoomValue(), "B3-11基层修改目标安排(管理)-D3-11基层修改安排-进入步骤房间值不能为空", false);
                Assert.isNull(updateGrootsEditReqDto.getBatchCode(), "B3-11基层修改目标安排(管理)-D3-11基层修改安排-批次标识不能为空", false);
                Assert.isNull(updateGrootsEditReqDto.getBatchCurrentStatus(), "B3-11基层修改目标安排(管理)-D3-11基层修改安排-批次现状不能为空", false);
                updateGrootsEditRespDto = fwAppOffStateClient.updateGrootsEdit(updateGrootsEditReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
        BffUpdateGrootsEditRespDto retData = new BffUpdateGrootsEditRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203676_1
        }


        return retData;
    }

    /**
     * B3-11更新目标内容父子状态(管理)[3781]
     * gen by moon at 12/26/2022, 5:05:42 PM
     */
    @Trace(operationName = "B3-11更新目标内容父子状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffRefreshTargetContentParentStateRespDto refreshTargetContentParentState(BffRefreshTargetContentParentStateReqDto reqDto) {


        //步骤0: D3-11更新目标内容父子状态(公共) - refreshTargetContentParentStateCom
        RefreshTargetContentParentStateComRespDto refreshTargetContentParentStateComRespDto = null;
        RefreshTargetContentParentStateComReqDto refreshTargetContentParentStateComReqDto = new RefreshTargetContentParentStateComReqDto();
        if (reqDto != null) {
            refreshTargetContentParentStateComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:373218_1
            refreshTargetContentParentStateComReqDto.setTargetCategoryId(reqDto.getTargetCategoryId());//SimpleFieldAssign//sourceId:367624_1
            refreshTargetContentParentStateComReqDto.setTargetObjList(reqDto.getTargetObjList());//list-field-assign//sourceId:367623_1
            refreshTargetContentParentStateComReqDto.setParentObjectiveId(reqDto.getParentObjectiveId());//SimpleFieldAssign//sourceId:373219_1
            refreshTargetContentParentStateComReqDto.setParentTargetCategoryId(reqDto.getParentTargetCategoryId());//SimpleFieldAssign//sourceId:373220_1
            refreshTargetContentParentStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:367626_1
            refreshTargetContentParentStateComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:406656_1
        }

        /*D3-11更新目标内容父子状态(公共)[4778]   */
        Assert.isNull(refreshTargetContentParentStateComReqDto.getObjectTypeCode(), "B3-11更新目标内容父子状态(管理)-D3-11更新目标内容父子状态(公共)-内容对象类型编码不能为空", false);
        Assert.isNull(refreshTargetContentParentStateComReqDto.getEvaluationTemplateId(), "B3-11更新目标内容父子状态(管理)-D3-11更新目标内容父子状态(公共)-冗余评价模板ID不能为空", false);
        refreshTargetContentParentStateComRespDto = fwAppOffStateClient.refreshTargetContentParentStateCom(refreshTargetContentParentStateComReqDto).getData();


        BffRefreshTargetContentParentStateRespDto retData = new BffRefreshTargetContentParentStateRespDto();


        return retData;
    }

    /**
     * B3-11查询目标内容父子状态本级完成情况(管理)[4004]
     * gen by moon at 10/8/2022, 3:10:19 AM
     */
    @Trace(operationName = "B3-11查询目标内容父子状态本级完成情况(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryTargetContPresentAssistStatusSelfListRespDto queryTargetContPresentAssistStatusSelfList(BffQueryTargetContPresentAssistStatusSelfListReqDto reqDto) {


        QueryTargetContPresentAssistStatusSelfListRespDto queryTargetContPresentAssistStatusSelfListRespDto_1 = null;
//步骤0: D3-11查询目标内容父子状态本级完成情况 - queryTargetContPresentAssistStatusSelfList
        QueryTargetContPresentAssistStatusSelfListRespDto queryTargetContPresentAssistStatusSelfListRespDto = null;
        QueryTargetContPresentAssistStatusSelfListReqDto queryTargetContPresentAssistStatusSelfListReqDto = new QueryTargetContPresentAssistStatusSelfListReqDto();
        if (reqDto != null) {
            queryTargetContPresentAssistStatusSelfListReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:369840_1
            queryTargetContPresentAssistStatusSelfListReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:369841_1
            queryTargetContPresentAssistStatusSelfListReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:369842_1
            queryTargetContPresentAssistStatusSelfListReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:369843_1
        }

        /*D3-11查询目标内容父子状态本级完成情况[4005]   */
        Assert.isNull(queryTargetContPresentAssistStatusSelfListReqDto.getTargetCycleContentTypeCode(), "B3-11查询目标内容父子状态本级完成情况(管理)-D3-11查询目标内容父子状态本级完成情况-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryTargetContPresentAssistStatusSelfListReqDto.getTargetCycleContentId(), "B3-11查询目标内容父子状态本级完成情况(管理)-D3-11查询目标内容父子状态本级完成情况-关联目标内容ID不能为空", false);
        Assert.isNull(queryTargetContPresentAssistStatusSelfListReqDto.getTargetId(), "B3-11查询目标内容父子状态本级完成情况(管理)-D3-11查询目标内容父子状态本级完成情况-冗余目标ID不能为空", false);
        queryTargetContPresentAssistStatusSelfListRespDto = fwAppOffStateClient.queryTargetContPresentAssistStatusSelfList(queryTargetContPresentAssistStatusSelfListReqDto).getData();


        queryTargetContPresentAssistStatusSelfListRespDto_1 = queryTargetContPresentAssistStatusSelfListRespDto;

        BffQueryTargetContPresentAssistStatusSelfListRespDto retData = new BffQueryTargetContPresentAssistStatusSelfListRespDto();
        if (queryTargetContPresentAssistStatusSelfListRespDto_1 != null) {
            retData.setAssistNodeStatusList(queryTargetContPresentAssistStatusSelfListRespDto_1.getAssistNodeStatusList().stream().map(item -> BeanUtil.toBean(item, BffAssistNodeStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:369848_1
        }


        return retData;
    }

    /**
     * B3-11设完成中层检查项状态(管理)[3966]
     * gen by moon at 5/4/2023, 3:20:36 PM
     */
    @Trace(operationName = "B3-11设完成中层检查项状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffCompleteMidExecuteTargetCheckItemRespDto completeMidExecuteTargetCheckItem(BffCompleteMidExecuteTargetCheckItemReqDto reqDto) {


        //步骤0: D3-11设完成中层执行目标安排检查项 - completeMidExecuteTargetCheckItem
        CompleteMidExecuteTargetCheckItemRespDto completeMidExecuteTargetCheckItemRespDto = null;
        CompleteMidExecuteTargetCheckItemReqDto completeMidExecuteTargetCheckItemReqDto = new CompleteMidExecuteTargetCheckItemReqDto();
        if (reqDto != null) {
            completeMidExecuteTargetCheckItemReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:881743_1
            completeMidExecuteTargetCheckItemReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:881744_1
            completeMidExecuteTargetCheckItemReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:881745_1
            completeMidExecuteTargetCheckItemReqDto.setEvaTempBatchMgtOperationType(reqDto.getEvaTempBatchMgtOperationType());//SimpleFieldAssign//sourceId:883026_1
        }

        /*D3-11设完成中层执行目标安排检查项[3967]   */
        Assert.isNull(completeMidExecuteTargetCheckItemReqDto.getCheckItemCode(), "B3-11设完成中层检查项状态(管理)-D3-11设完成中层执行目标安排检查项-检查项标识不能为空", false);
        Assert.isNull(completeMidExecuteTargetCheckItemReqDto.getDeptTargetTaskBookId(), "B3-11设完成中层检查项状态(管理)-D3-11设完成中层执行目标安排检查项-部门目标任务书ID不能为空", false);
        Assert.isNull(completeMidExecuteTargetCheckItemReqDto.getEvaluationTemplateId(), "B3-11设完成中层检查项状态(管理)-D3-11设完成中层执行目标安排检查项-冗余评价模板ID不能为空", false);
        Assert.isNull(completeMidExecuteTargetCheckItemReqDto.getEvaTempBatchMgtOperationType(), "B3-11设完成中层检查项状态(管理)-D3-11设完成中层执行目标安排检查项-评价模板批次下管理操作类型不能为空", false);
        completeMidExecuteTargetCheckItemRespDto = fwAppOffStateClient.completeMidExecuteTargetCheckItem(completeMidExecuteTargetCheckItemReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffCompleteMidExecuteTargetCheckItemRespDto retData = new BffCompleteMidExecuteTargetCheckItemRespDto();


        return retData;
    }

    /**
     * B3-11取消完成中层检查项状态(管理)[3976]
     * gen by moon at 5/3/2023, 11:27:56 PM
     */
    @Trace(operationName = "B3-11取消完成中层检查项状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffCancelCompleteMidExecuteTargetCheckItemRespDto cancelCompleteMidExecuteTargetCheckItem(BffCancelCompleteMidExecuteTargetCheckItemReqDto reqDto) {


        //步骤0: D3-11取消完成中层执行目标安排检查项 - cancelCompleteMidExecuteTargetCheckItem
        CancelCompleteMidExecuteTargetCheckItemRespDto cancelCompleteMidExecuteTargetCheckItemRespDto = null;
        CancelCompleteMidExecuteTargetCheckItemReqDto cancelCompleteMidExecuteTargetCheckItemReqDto = new CancelCompleteMidExecuteTargetCheckItemReqDto();
        if (reqDto != null) {
            cancelCompleteMidExecuteTargetCheckItemReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:880551_1
            cancelCompleteMidExecuteTargetCheckItemReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:880435_1
            cancelCompleteMidExecuteTargetCheckItemReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334821_1
            cancelCompleteMidExecuteTargetCheckItemReqDto.setEvaTempBatchMgtOperationType(reqDto.getEvaTempBatchMgtOperationType());//SimpleFieldAssign//sourceId:341285_1
        }

        /*D3-11取消完成中层执行目标安排检查项[3977]   */
        Assert.isNull(cancelCompleteMidExecuteTargetCheckItemReqDto.getCheckItemCode(), "B3-11取消完成中层检查项状态(管理)-D3-11取消完成中层执行目标安排检查项-检查项标识不能为空", false);
        Assert.isNull(cancelCompleteMidExecuteTargetCheckItemReqDto.getDeptTargetTaskBookId(), "B3-11取消完成中层检查项状态(管理)-D3-11取消完成中层执行目标安排检查项-部门目标任务书ID不能为空", false);
        Assert.isNull(cancelCompleteMidExecuteTargetCheckItemReqDto.getEvaluationTemplateId(), "B3-11取消完成中层检查项状态(管理)-D3-11取消完成中层执行目标安排检查项-冗余评价模板ID不能为空", false);
        Assert.isNull(cancelCompleteMidExecuteTargetCheckItemReqDto.getEvaTempBatchMgtOperationType(), "B3-11取消完成中层检查项状态(管理)-D3-11取消完成中层执行目标安排检查项-评价模板批次下管理操作类型不能为空", false);
        cancelCompleteMidExecuteTargetCheckItemRespDto = fwAppOffStateClient.cancelCompleteMidExecuteTargetCheckItem(cancelCompleteMidExecuteTargetCheckItemReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffCancelCompleteMidExecuteTargetCheckItemRespDto retData = new BffCancelCompleteMidExecuteTargetCheckItemRespDto();


        return retData;
    }

    /**
     * B3-11设完成基层执行目标任务安排检查项(管理)[4678]
     * gen by moon at 11/8/2022, 5:43:54 AM
     */
    @Trace(operationName = "B3-11设完成基层执行目标任务安排检查项(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffCompleteBasicExecuteTargetCheckItemRespDto completeBasicExecuteTargetCheckItem(BffCompleteBasicExecuteTargetCheckItemReqDto reqDto) {


        //步骤0: D3-11设完成基层执行目标任务安排检查项 - completeBasicExecuteTargetCheckItem
        CompleteBasicExecuteTargetCheckItemRespDto completeBasicExecuteTargetCheckItemRespDto = null;
        CompleteBasicExecuteTargetCheckItemReqDto completeBasicExecuteTargetCheckItemReqDto = new CompleteBasicExecuteTargetCheckItemReqDto();
        if (reqDto != null) {
            completeBasicExecuteTargetCheckItemReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:341391_1
            completeBasicExecuteTargetCheckItemReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:341393_1
        }

        /*D3-11设完成基层执行目标任务安排检查项[4680]   */
        Assert.isNull(completeBasicExecuteTargetCheckItemReqDto.getTargetId(), "B3-11设完成基层执行目标任务安排检查项(管理)-D3-11设完成基层执行目标任务安排检查项-目标ID不能为空", false);
        Assert.isNull(completeBasicExecuteTargetCheckItemReqDto.getDeptId(), "B3-11设完成基层执行目标任务安排检查项(管理)-D3-11设完成基层执行目标任务安排检查项-部门ID不能为空", false);
        completeBasicExecuteTargetCheckItemRespDto = fwAppOffStateClient.completeBasicExecuteTargetCheckItem(completeBasicExecuteTargetCheckItemReqDto).getData();


        BffCompleteBasicExecuteTargetCheckItemRespDto retData = new BffCompleteBasicExecuteTargetCheckItemRespDto();


        return retData;
    }

    /**
     * B3-11取消完成基层执行目标任务安排检查项(管理)[4679]
     * gen by moon at 11/8/2022, 5:43:56 AM
     */
    @Trace(operationName = "B3-11取消完成基层执行目标任务安排检查项(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffCancelCompleteBasicExecuteTargetCheckItemRespDto cancelCompleteBasicExecuteTargetCheckItem(BffCancelCompleteBasicExecuteTargetCheckItemReqDto reqDto) {


        //步骤0: D3-11取消完成基层执行目标任务安排检查项 - cancelCompleteBasicExecuteTargetCheckItem
        CancelCompleteBasicExecuteTargetCheckItemRespDto cancelCompleteBasicExecuteTargetCheckItemRespDto = null;
        CancelCompleteBasicExecuteTargetCheckItemReqDto cancelCompleteBasicExecuteTargetCheckItemReqDto = new CancelCompleteBasicExecuteTargetCheckItemReqDto();
        if (reqDto != null) {
            cancelCompleteBasicExecuteTargetCheckItemReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:341364_1
            cancelCompleteBasicExecuteTargetCheckItemReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:341366_1
        }

        /*D3-11取消完成基层执行目标任务安排检查项[4681]   */
        Assert.isNull(cancelCompleteBasicExecuteTargetCheckItemReqDto.getTargetId(), "B3-11取消完成基层执行目标任务安排检查项(管理)-D3-11取消完成基层执行目标任务安排检查项-目标ID不能为空", false);
        Assert.isNull(cancelCompleteBasicExecuteTargetCheckItemReqDto.getDeptId(), "B3-11取消完成基层执行目标任务安排检查项(管理)-D3-11取消完成基层执行目标任务安排检查项-部门ID不能为空", false);
        cancelCompleteBasicExecuteTargetCheckItemRespDto = fwAppOffStateClient.cancelCompleteBasicExecuteTargetCheckItem(cancelCompleteBasicExecuteTargetCheckItemReqDto).getData();


        BffCancelCompleteBasicExecuteTargetCheckItemRespDto retData = new BffCancelCompleteBasicExecuteTargetCheckItemRespDto();


        return retData;
    }

    /**
     * B3查询目标内容融合仪表盘列表(管理)[4960]
     * gen by moon at 11/29/2022, 8:06:09 PM
     */
    @Trace(operationName = "B3查询目标内容融合仪表盘列表(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryTargetFusionDashboardListRespDto queryTargetFusionDashboardList(BffQueryTargetFusionDashboardListReqDto reqDto) {


        QueryCheckItemPanelListComRespDto queryCheckItemPanelListComRespDto_1 = null;
//步骤0: D3-11查询检查仪表盘列表(公共) - queryCheckItemPanelListCom
        QueryCheckItemPanelListComRespDto queryCheckItemPanelListComRespDto = null;
        QueryCheckItemPanelListComReqDto queryCheckItemPanelListComReqDto = new QueryCheckItemPanelListComReqDto();
        if (reqDto != null) {
            queryCheckItemPanelListComReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//SimpleFieldAssign//sourceId:383906_1
            queryCheckItemPanelListComReqDto.setCheckObjectTypeCode(reqDto.getCheckObjectTypeCode());//SimpleFieldAssign//sourceId:383908_1
        }

        /*D3-11查询检查仪表盘列表(公共)[2716]   */
        Assert.isNull(queryCheckItemPanelListComReqDto.getCheckObjectTypeId(), "B3查询目标内容融合仪表盘列表(管理)-D3-11查询检查仪表盘列表(公共)-检查内容对象ID 不能为空", false);
        Assert.isNull(queryCheckItemPanelListComReqDto.getCheckObjectTypeCode(), "B3查询目标内容融合仪表盘列表(管理)-D3-11查询检查仪表盘列表(公共)-检查内容对象类型编码不能为空", false);
        queryCheckItemPanelListComRespDto = fwAppOffStateClient.queryCheckItemPanelListCom(queryCheckItemPanelListComReqDto).getData();


        queryCheckItemPanelListComRespDto_1 = queryCheckItemPanelListComRespDto;

        BffQueryTargetFusionDashboardListRespDto retData = new BffQueryTargetFusionDashboardListRespDto();
        if (queryCheckItemPanelListComRespDto_1 != null) {
            retData.setTargetDashboardCompletionStatusList(queryCheckItemPanelListComRespDto_1.getTargetDashboardCompletionStatusList().stream().map(item -> BeanUtil.toBean(item, BffTargetDashboardCompletionStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:430391_1
            retData.setMolecule(queryCheckItemPanelListComRespDto_1.getMolecule());//SimpleFieldAssign//sourceId:429242_1
            retData.setDenominator(queryCheckItemPanelListComRespDto_1.getDenominator());//SimpleFieldAssign//sourceId:429243_1
            retData.setOutputNum(queryCheckItemPanelListComRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:429244_1
        }


        return retData;
    }

    /**
     * B2-9查询评价主题步骤列表(边界)[4999]
     * gen by moon at 10/24/2022, 4:32:03 AM
     */
    @Trace(operationName = "B2-9查询评价主题步骤列表(边界)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryEvaThemeStepListBorderRespDto queryEvaThemeStepListBorder(BffQueryEvaThemeStepListBorderReqDto reqDto) {


        QueryEvaThemeStepListRespDto queryEvaThemeStepListRespDto_1 = null;
//步骤0: D2-9查询评价主题步骤列表 - queryEvaThemeStepList
        QueryEvaThemeStepListRespDto queryEvaThemeStepListRespDto = null;
        QueryEvaThemeStepListReqDto queryEvaThemeStepListReqDto = new QueryEvaThemeStepListReqDto();


        /*D2-9查询评价主题步骤列表[5000]   */

        queryEvaThemeStepListRespDto = fwCompOffStateClient.queryEvaThemeStepList(queryEvaThemeStepListReqDto).getData();


        queryEvaThemeStepListRespDto_1 = queryEvaThemeStepListRespDto;

        BffQueryEvaThemeStepListBorderRespDto retData = new BffQueryEvaThemeStepListBorderRespDto();
        if (queryEvaThemeStepListRespDto_1 != null) {
            retData.setStepList(queryEvaThemeStepListRespDto_1.getStepList().stream().map(item -> BeanUtil.toBean(item, BffStepDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:388520_1
        }


        return retData;
    }

    /**
     * B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)[5034]
     * gen by moon at 10/30/2023, 3:32:10 PM
     */
    @Trace(operationName = "B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto queryMidBrotherDeptDivArrangeCheckItemStatusList(BffQueryMidBrotherDeptDivArrangeCheckItemStatusListReqDto reqDto) {


        QueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1 = null;
//步骤0: D3-13查询中层兄弟部门分工安排检查项完成情况列表 - queryMidBrotherDeptDivArrangeCheckItemStatusList
        QueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto = null;
        QueryMidBrotherDeptDivArrangeCheckItemStatusListReqDto queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto = new QueryMidBrotherDeptDivArrangeCheckItemStatusListReqDto();
        if (reqDto != null) {
            queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:408738_1
            queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:407127_1
            queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:407753_1
            queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1058668_1
            queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1136326_1
            queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setMgtType(reqDto.getMgtType());//SimpleFieldAssign//sourceId:1136327_1
            queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.setTargetDivTierSet(reqDto.getTargetDivTierSet());//SimpleFieldAssign//sourceId:1213366_1
        }

        /*D3-13查询中层兄弟部门分工安排检查项完成情况列表[5036]   */
        Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getDeptId(), "B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-部门ID不能为空", false);
        Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getCheckItemCode(), "B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-检查项标识不能为空", false);
        Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getEvaluationTemplateId(), "B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-冗余评价模板ID不能为空", false);
        Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getBatchCode(), "B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-批次标识不能为空", false);
        Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getBatchCurrentStatus(), "B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-批次现状不能为空", false);
        Assert.isNull(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto.getMgtType(), "B3-13查询中层兄弟部门分工安排检查项完成情况列表(管理)-D3-13查询中层兄弟部门分工安排检查项完成情况列表-管理类型不能为空", false);
        queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto = fwAppOffStateClient.queryMidBrotherDeptDivArrangeCheckItemStatusList(queryMidBrotherDeptDivArrangeCheckItemStatusListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1 = queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto;

        BffQueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto retData = new BffQueryMidBrotherDeptDivArrangeCheckItemStatusListRespDto();
        if (queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1 != null) {
            retData.setDeptTargetTaskBookIdList(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1.getDeptTargetTaskBookIdList().stream().map(item -> BeanUtil.toBean(item, BffDeptTargetTaskBookIdDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:407764_1
            retData.setDoneCalcCount(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1.getDoneCalcCount());//SimpleFieldAssign//sourceId:1141150_1
            retData.setAllCalcCount(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1.getAllCalcCount());//SimpleFieldAssign//sourceId:1141151_1
            retData.setIsAllArrangeAccomplish(queryMidBrotherDeptDivArrangeCheckItemStatusListRespDto_1.getIsAllArrangeAccomplish());//SimpleFieldAssign//sourceId:1141152_1
        }


        return retData;
    }

    /**
     * B3-13查询部门目标任务书根节点检查项状态(管理)[5058]
     * gen by moon at 9/22/2023, 6:50:32 PM
     */
    @Trace(operationName = "B3-13查询部门目标任务书根节点检查项状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryDeptTargetRootNodeCheckItemStatDetailRespDto queryDeptTargetRootNodeCheckItemStatDetail(BffQueryDeptTargetRootNodeCheckItemStatDetailReqDto reqDto) {


        QueryDeptTargetRootNodeCheckItemStatDetailRespDto queryDeptTargetRootNodeCheckItemStatDetailRespDto_1 = null;
//步骤0: D3-13查询部门目标任务书根节点检查项状态 - queryDeptTargetRootNodeCheckItemStatDetail
        QueryDeptTargetRootNodeCheckItemStatDetailRespDto queryDeptTargetRootNodeCheckItemStatDetailRespDto = null;
        QueryDeptTargetRootNodeCheckItemStatDetailReqDto queryDeptTargetRootNodeCheckItemStatDetailReqDto = new QueryDeptTargetRootNodeCheckItemStatDetailReqDto();
        if (reqDto != null) {
            queryDeptTargetRootNodeCheckItemStatDetailReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:408152_1
            queryDeptTargetRootNodeCheckItemStatDetailReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:408153_1
            queryDeptTargetRootNodeCheckItemStatDetailReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:408154_1
            queryDeptTargetRootNodeCheckItemStatDetailReqDto.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:482026_1
        }

        /*D3-13查询部门目标任务书根节点检查项状态[5059]   */
        Assert.isNull(queryDeptTargetRootNodeCheckItemStatDetailReqDto.getDeptId(), "B3-13查询部门目标任务书根节点检查项状态(管理)-D3-13查询部门目标任务书根节点检查项状态-部门ID不能为空", false);
        Assert.isNull(queryDeptTargetRootNodeCheckItemStatDetailReqDto.getEvaluationTemplateId(), "B3-13查询部门目标任务书根节点检查项状态(管理)-D3-13查询部门目标任务书根节点检查项状态-冗余评价模板ID不能为空", false);
        Assert.isNull(queryDeptTargetRootNodeCheckItemStatDetailReqDto.getCheckItemCode(), "B3-13查询部门目标任务书根节点检查项状态(管理)-D3-13查询部门目标任务书根节点检查项状态-检查项标识不能为空", false);
        queryDeptTargetRootNodeCheckItemStatDetailRespDto = fwAppOffStateClient.queryDeptTargetRootNodeCheckItemStatDetail(queryDeptTargetRootNodeCheckItemStatDetailReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryDeptTargetRootNodeCheckItemStatDetailRespDto_1 = queryDeptTargetRootNodeCheckItemStatDetailRespDto;

        BffQueryDeptTargetRootNodeCheckItemStatDetailRespDto retData = new BffQueryDeptTargetRootNodeCheckItemStatDetailRespDto();
        if (queryDeptTargetRootNodeCheckItemStatDetailRespDto_1 != null) {
            retData.setCheckItemCode(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getCheckItemCode());//SimpleFieldAssign//sourceId:408167_1
            retData.setCheckItemName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getCheckItemName());//SimpleFieldAssign//sourceId:408168_1
            retData.setIsComplete(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:628844_1
            retData.setDeptId(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDeptId());//SimpleFieldAssign//sourceId:408170_1
            retData.setDeptShortName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDeptShortName());//SimpleFieldAssign//sourceId:408171_1
            retData.setDeptLeaderIdCardName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDeptLeaderIdCardName());//SimpleFieldAssign//sourceId:1128932_1
            retData.setDeptLeaderNickName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDeptLeaderNickName());//SimpleFieldAssign//sourceId:1128933_1
            retData.setDirectorIdCardName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDirectorIdCardName());//SimpleFieldAssign//sourceId:1132834_1
            retData.setPartyAndYouthDirectorIdCardName(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getPartyAndYouthDirectorIdCardName());//SimpleFieldAssign//sourceId:1132835_1
            retData.setMoleculeValue(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getMoleculeValue());//SimpleFieldAssign//sourceId:604046_1
            retData.setDenominatorValue(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getDenominatorValue());//SimpleFieldAssign//sourceId:604047_1
            retData.setIsDivComplete(queryDeptTargetRootNodeCheckItemStatDetailRespDto_1.getIsDivComplete());//SimpleFieldAssign//sourceId:628845_1
        }


        return retData;
    }

    /**
     * B3-11修改高层目标检查项(管理)[2931]
     * gen by moon at 10/29/2022, 6:30:55 PM
     */
    @Trace(operationName = "B3-11修改高层目标检查项(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateTopTargetCheckItemStatusRespDto updateTopTargetCheckItemStatus(BffUpdateTopTargetCheckItemStatusReqDto reqDto) {


        //步骤0: D3-11修改高层目标检查项(公共) - updateTopTargetCheckItemStatusCom
        UpdateTopTargetCheckItemStatusComRespDto updateTopTargetCheckItemStatusComRespDto = null;
        UpdateTopTargetCheckItemStatusComReqDto updateTopTargetCheckItemStatusComReqDto = new UpdateTopTargetCheckItemStatusComReqDto();
        updateTopTargetCheckItemStatusComReqDto.setEvaTempBatchMgtOperationType("MIXTURE_OPERATION");//sourceId:330007_1
        if (reqDto != null) {
            updateTopTargetCheckItemStatusComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:218037_1
            updateTopTargetCheckItemStatusComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:218038_1
            updateTopTargetCheckItemStatusComReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:218039_1
            updateTopTargetCheckItemStatusComReqDto.setIsComplete(reqDto.getIsComplete());//SimpleFieldAssign//sourceId:218040_1
        }

        /*D3-11修改高层目标检查项(公共)[4034]   */
        Assert.isNull(updateTopTargetCheckItemStatusComReqDto.getEvaTempBatchMgtOperationType(), "B3-11修改高层目标检查项(管理)-D3-11修改高层目标检查项(公共)-评价模板批次下管理操作类型不能为空", false);
        Assert.isNull(updateTopTargetCheckItemStatusComReqDto.getTargetId(), "B3-11修改高层目标检查项(管理)-D3-11修改高层目标检查项(公共)-冗余目标ID不能为空", false);
        Assert.isNull(updateTopTargetCheckItemStatusComReqDto.getEvaluationTemplateId(), "B3-11修改高层目标检查项(管理)-D3-11修改高层目标检查项(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(updateTopTargetCheckItemStatusComReqDto.getCheckItemCode(), "B3-11修改高层目标检查项(管理)-D3-11修改高层目标检查项(公共)-检查项标识不能为空", false);
        updateTopTargetCheckItemStatusComRespDto = fwAppOffStateClient.updateTopTargetCheckItemStatusCom(updateTopTargetCheckItemStatusComReqDto).getData();


        BffUpdateTopTargetCheckItemStatusRespDto retData = new BffUpdateTopTargetCheckItemStatusRespDto();


        return retData;
    }

    /**
     * B3-13查询公共业务应用校验项状态(管理)[4620]
     * gen by moon at 11/9/2022, 9:13:19 PM
     */
    @Trace(operationName = "B3-13查询公共业务应用校验项状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryComCheckItemStatDetailRespDto queryComCheckItemStatDetail(BffQueryComCheckItemStatDetailReqDto reqDto) {


        QueryComCheckItemStatDetailRespDto queryComCheckItemStatDetailRespDto_1 = null;
//步骤0: D3-13查询公共业务应用校验项状态 - queryComCheckItemStatDetail
        QueryComCheckItemStatDetailRespDto queryComCheckItemStatDetailRespDto = null;
        QueryComCheckItemStatDetailReqDto queryComCheckItemStatDetailReqDto = new QueryComCheckItemStatDetailReqDto();
        if (reqDto != null) {
            queryComCheckItemStatDetailReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:335795_1
            queryComCheckItemStatDetailReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:335796_1
            queryComCheckItemStatDetailReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:335797_1
        }

        /*D3-13查询公共业务应用校验项状态[4621]   */
        Assert.isNull(queryComCheckItemStatDetailReqDto.getCheckItemCode(), "B3-13查询公共业务应用校验项状态(管理)-D3-13查询公共业务应用校验项状态-检查项标识不能为空", false);
        Assert.isNull(queryComCheckItemStatDetailReqDto.getEntityId(), "B3-13查询公共业务应用校验项状态(管理)-D3-13查询公共业务应用校验项状态-内容对象实例ID不能为空", false);
        Assert.isNull(queryComCheckItemStatDetailReqDto.getObjectTypeCode(), "B3-13查询公共业务应用校验项状态(管理)-D3-13查询公共业务应用校验项状态-内容对象类型编码不能为空", false);
        queryComCheckItemStatDetailRespDto = fwAppOffStateClient.queryComCheckItemStatDetail(queryComCheckItemStatDetailReqDto).getData();


        queryComCheckItemStatDetailRespDto_1 = queryComCheckItemStatDetailRespDto;

        BffQueryComCheckItemStatDetailRespDto retData = new BffQueryComCheckItemStatDetailRespDto();
        if (queryComCheckItemStatDetailRespDto_1 != null) {
            retData.setStatusCheckItemId(queryComCheckItemStatDetailRespDto_1.getStatusCheckItemId());//SimpleFieldAssign//sourceId:335804_1
            retData.setIsComplete(queryComCheckItemStatDetailRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:335805_1
        }


        return retData;
    }

    /**
     * B3查询融合目标检查项父子状态列表(管理)[4961]
     * gen by moon at 6/10/2023, 1:13:30 AM
     */
    @Trace(operationName = "B3查询融合目标检查项父子状态列表(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryFuseTargetCheckItemNodeStatusListRespDto queryFuseTargetCheckItemNodeStatusList(BffQueryFuseTargetCheckItemNodeStatusListReqDto reqDto) {


        QueryFuseTargetCheckItemNodeStatusListRespDto queryFuseTargetCheckItemNodeStatusListRespDto_1 = null;
        ImplementCheckItemRespDto implementCheckItemRespDto_1 = null;
//步骤0: D3查询融合目标检查项父子状态列表 - queryFuseTargetCheckItemNodeStatusList
        QueryFuseTargetCheckItemNodeStatusListRespDto queryFuseTargetCheckItemNodeStatusListRespDto = null;
        QueryFuseTargetCheckItemNodeStatusListReqDto queryFuseTargetCheckItemNodeStatusListReqDto = new QueryFuseTargetCheckItemNodeStatusListReqDto();
        if (reqDto != null) {
            queryFuseTargetCheckItemNodeStatusListReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:383968_1
        }

        /*D3查询融合目标检查项父子状态列表[4962]   */
        Assert.isNull(queryFuseTargetCheckItemNodeStatusListReqDto.getEntityId(), "B3查询融合目标检查项父子状态列表(管理)-D3查询融合目标检查项父子状态列表-目标ID不能为空", false);
        queryFuseTargetCheckItemNodeStatusListRespDto = fwAppOffStateClient.queryFuseTargetCheckItemNodeStatusList(queryFuseTargetCheckItemNodeStatusListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryFuseTargetCheckItemNodeStatusListRespDto_1 = queryFuseTargetCheckItemNodeStatusListRespDto;

//步骤1: D3-11批量查询检查项 - batchQueryCheckItem
        BatchQueryCheckItemRespDto batchQueryCheckItemRespDto = null;
        if (queryFuseTargetCheckItemNodeStatusListRespDto != null) {
            BatchQueryCheckItemReqDto batchQueryCheckItemReqDto = new BatchQueryCheckItemReqDto();
            batchQueryCheckItemReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:383936_1
            if (queryFuseTargetCheckItemNodeStatusListRespDto != null && queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList() != null && !CollectionUtil.isEmpty(queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList())) {
                batchQueryCheckItemReqDto.setCheckItemList(queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList().stream().map(item -> item.getCheckItemCode())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:383935_1
            }

            /*D3-11批量查询检查项[3978]   */
            Assert.isNull(batchQueryCheckItemReqDto.getSubjectLifeCycle(), "B3查询融合目标检查项父子状态列表(管理)-D3-11批量查询检查项-主体生命周期不能为空", false);
            batchQueryCheckItemRespDto = fwAppOffStateClient.batchQueryCheckItem(batchQueryCheckItemReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }

//步骤2: D3执行检查项 - implementCheckItem
        ImplementCheckItemRespDto implementCheckItemRespDto = null;
        if (queryFuseTargetCheckItemNodeStatusListRespDto != null) {
            ImplementCheckItemReqDto implementCheckItemReqDto = new ImplementCheckItemReqDto();
            if (queryFuseTargetCheckItemNodeStatusListRespDto != null && queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList() != null && !CollectionUtil.isEmpty(queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList())) {
                implementCheckItemReqDto.setBizAppCheckItemStatList(queryFuseTargetCheckItemNodeStatusListRespDto.getBizAppCheckItemStatList().stream().map(item -> BeanUtil.toBean(item, BizAppCheckItemStatDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:384219_1
            }
            if (batchQueryCheckItemRespDto != null && batchQueryCheckItemRespDto.getCheckItemList() != null && !CollectionUtil.isEmpty(batchQueryCheckItemRespDto.getCheckItemList())) {
                implementCheckItemReqDto.setCheckItemFusionMainContentList(batchQueryCheckItemRespDto.getCheckItemList().stream().map(item -> BeanUtil.toBean(item, CheckItemFusionMainContentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:384218_1
            }

            /*D3执行检查项[4970]   */

            implementCheckItemRespDto = fwAppOffStateClient.implementCheckItem(implementCheckItemReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementCheckItemRespDto_1 = implementCheckItemRespDto;
        }

        BffQueryFuseTargetCheckItemNodeStatusListRespDto retData = new BffQueryFuseTargetCheckItemNodeStatusListRespDto();
        if (queryFuseTargetCheckItemNodeStatusListRespDto_1 != null) {
            retData.setTargetCheckItemStatusList(queryFuseTargetCheckItemNodeStatusListRespDto_1.getSetConstructionTaskList().stream().map(item -> BeanUtil.toBean(item, BffTargetCheckItemStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:384017_1
            retData.setComFloatField1(queryFuseTargetCheckItemNodeStatusListRespDto_1.getComFloatField1());//SimpleFieldAssign//sourceId:545420_1
            retData.setComFloatField2(queryFuseTargetCheckItemNodeStatusListRespDto_1.getComFloatField2());//SimpleFieldAssign//sourceId:545421_1
            retData.setIsComplete(queryFuseTargetCheckItemNodeStatusListRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:545422_1
            retData.setTargetIsComplete(queryFuseTargetCheckItemNodeStatusListRespDto_1.getTargetIsComplete());//SimpleFieldAssign//sourceId:1028558_1
            retData.setSetCompleteStatus(queryFuseTargetCheckItemNodeStatusListRespDto_1.getSetCompleteStatus());//SimpleFieldAssign//sourceId:552082_1
        }
        if (implementCheckItemRespDto_1 != null) {
            retData.setBizAppCheckItemStatList(implementCheckItemRespDto_1.getBizAppCheckItemStatList().stream().map(item -> BeanUtil.toBean(item, BffBizAppCheckItemStatDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:523964_1
        }


        return retData;
    }

    /**
     * B3-13查询基层执行目标任务安排检查项(管理)[4620]
     * gen by moon at 9/22/2023, 6:50:28 PM
     */
    @Trace(operationName = "B3-13查询基层执行目标任务安排检查项(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryBasicExecuteTargetCheckItemDetailRespDto queryBasicExecuteTargetCheckItemDetail(BffQueryBasicExecuteTargetCheckItemDetailReqDto reqDto) {


        QueryGrootsTargetTaskDivArrangeStatusDetailRespDto queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1 = null;
//步骤0: D3-13查询基层目标任务分工安排状态详情 - queryGrootsTargetTaskDivArrangeStatusDetail
        QueryGrootsTargetTaskDivArrangeStatusDetailRespDto queryGrootsTargetTaskDivArrangeStatusDetailRespDto = null;
        QueryGrootsTargetTaskDivArrangeStatusDetailReqDto queryGrootsTargetTaskDivArrangeStatusDetailReqDto = new QueryGrootsTargetTaskDivArrangeStatusDetailReqDto();
        queryGrootsTargetTaskDivArrangeStatusDetailReqDto.setCheckItemCode("PERFORM_TARGET_TASK_ARRANGE_CHECK_ITEM");//CUSTOM_CONVENTION//sourceId:585909_1
        if (reqDto != null) {
            queryGrootsTargetTaskDivArrangeStatusDetailReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:585908_1
        }

        /*D3-13查询基层目标任务分工安排状态详情[4621]   */
        Assert.isNull(queryGrootsTargetTaskDivArrangeStatusDetailReqDto.getEvaObjTargetCycleId(), "B3-13查询基层执行目标任务安排检查项(管理)-D3-13查询基层目标任务分工安排状态详情-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryGrootsTargetTaskDivArrangeStatusDetailReqDto.getCheckItemCode(), "B3-13查询基层执行目标任务安排检查项(管理)-D3-13查询基层目标任务分工安排状态详情-检查项标识不能为空", false);
        queryGrootsTargetTaskDivArrangeStatusDetailRespDto = fwAppOffStateClient.queryGrootsTargetTaskDivArrangeStatusDetail(queryGrootsTargetTaskDivArrangeStatusDetailReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1 = queryGrootsTargetTaskDivArrangeStatusDetailRespDto;

        BffQueryBasicExecuteTargetCheckItemDetailRespDto retData = new BffQueryBasicExecuteTargetCheckItemDetailRespDto();
        if (queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1 != null) {
            retData.setCheckItemCode(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getCheckItemCode());//SimpleFieldAssign//sourceId:585913_1
            retData.setCheckItemName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getCheckItemName());//SimpleFieldAssign//sourceId:429384_1
            retData.setIsComplete(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:628840_1
            retData.setDeptId(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDeptId());//SimpleFieldAssign//sourceId:585919_1
            retData.setDeptShortName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDeptShortName());//SimpleFieldAssign//sourceId:429385_1
            retData.setDeptLeaderIdCardName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDeptLeaderIdCardName());//SimpleFieldAssign//sourceId:1128960_1
            retData.setDeptLeaderNickName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDeptLeaderNickName());//SimpleFieldAssign//sourceId:1128961_1
            retData.setDirectorIdCardName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDirectorIdCardName());//SimpleFieldAssign//sourceId:1132840_1
            retData.setPartyAndYouthDirectorIdCardName(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getPartyAndYouthDirectorIdCardName());//SimpleFieldAssign//sourceId:1132841_1
            retData.setMoleculeValue(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getMoleculeValue());//SimpleFieldAssign//sourceId:604079_1
            retData.setDenominatorValue(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getDenominatorValue());//SimpleFieldAssign//sourceId:604080_1
            retData.setIsDivComplete(queryGrootsTargetTaskDivArrangeStatusDetailRespDto_1.getIsDivComplete());//SimpleFieldAssign//sourceId:628841_1
        }


        return retData;
    }

    /**
     * B3-11查询部门安排进度(管理)[5397]
     * gen by moon at 12/5/2022, 5:37:59 PM
     */
    @Trace(operationName = "B3-11查询部门安排进度(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryDeptArrangeScheduleDetailRespDto queryDeptArrangeScheduleDetail(BffQueryDeptArrangeScheduleDetailReqDto reqDto) {


        QueryDeptArrangeScheduleDetailComRespDto queryDeptArrangeScheduleDetailComRespDto_1 = null;
//步骤0: D3-11查询部门安排进度详情(公共) - queryDeptArrangeScheduleDetailCom
        QueryDeptArrangeScheduleDetailComRespDto queryDeptArrangeScheduleDetailComRespDto = null;
        QueryDeptArrangeScheduleDetailComReqDto queryDeptArrangeScheduleDetailComReqDto = new QueryDeptArrangeScheduleDetailComReqDto();
        if (reqDto != null) {
            queryDeptArrangeScheduleDetailComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:487588_1
            queryDeptArrangeScheduleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:487589_1
        }

        /*D3-11查询部门安排进度详情(公共)[5398]   */
        Assert.isNull(queryDeptArrangeScheduleDetailComReqDto.getDeptId(), "B3-11查询部门安排进度(管理)-D3-11查询部门安排进度详情(公共)-部门ID不能为空", false);
        Assert.isNull(queryDeptArrangeScheduleDetailComReqDto.getEvaluationTemplateId(), "B3-11查询部门安排进度(管理)-D3-11查询部门安排进度详情(公共)-冗余评价模板ID不能为空", false);
        queryDeptArrangeScheduleDetailComRespDto = fwAppOffStateClient.queryDeptArrangeScheduleDetailCom(queryDeptArrangeScheduleDetailComReqDto).getData();


        queryDeptArrangeScheduleDetailComRespDto_1 = queryDeptArrangeScheduleDetailComRespDto;

        BffQueryDeptArrangeScheduleDetailRespDto retData = new BffQueryDeptArrangeScheduleDetailRespDto();
        if (queryDeptArrangeScheduleDetailComRespDto_1 != null) {
            retData.setMoleculeValue(queryDeptArrangeScheduleDetailComRespDto_1.getMoleculeValue());//SimpleFieldAssign//sourceId:487596_1
            retData.setDenominatorValue(queryDeptArrangeScheduleDetailComRespDto_1.getDenominatorValue());//SimpleFieldAssign//sourceId:487597_1
            retData.setIsComplete(queryDeptArrangeScheduleDetailComRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:487598_1
        }


        return retData;
    }

    /**
     * B3查询目标内容检查项状态列表[5517]
     * gen by moon at 12/25/2022, 7:28:08 PM
     */
    @Trace(operationName = "B3查询目标内容检查项状态列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryTargetContCheckItemStateListRespDto queryTargetContCheckItemStateList(BffQueryTargetContCheckItemStateListReqDto reqDto) {


        QueryTargetContCheckItemStateListRespDto queryTargetContCheckItemStateListRespDto_1 = null;
//步骤0: D3查询目标内容检查项状态列表 - queryTargetContCheckItemStateList
        QueryTargetContCheckItemStateListRespDto queryTargetContCheckItemStateListRespDto = null;
        QueryTargetContCheckItemStateListReqDto queryTargetContCheckItemStateListReqDto = new QueryTargetContCheckItemStateListReqDto();
        if (reqDto != null) {
            queryTargetContCheckItemStateListReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:544158_1
            queryTargetContCheckItemStateListReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:544159_1
        }

        /*D3查询目标内容检查项状态列表[5516]   */
        Assert.isNull(queryTargetContCheckItemStateListReqDto.getObjectTypeCode(), "B3查询目标内容检查项状态列表-D3查询目标内容检查项状态列表-内容对象类型编码不能为空", false);
        Assert.isNull(queryTargetContCheckItemStateListReqDto.getEntityId(), "B3查询目标内容检查项状态列表-D3查询目标内容检查项状态列表-内容对象实例ID不能为空", false);
        queryTargetContCheckItemStateListRespDto = fwAppOffStateClient.queryTargetContCheckItemStateList(queryTargetContCheckItemStateListReqDto).getData();


        queryTargetContCheckItemStateListRespDto_1 = queryTargetContCheckItemStateListRespDto;

        BffQueryTargetContCheckItemStateListRespDto retData = new BffQueryTargetContCheckItemStateListRespDto();
        if (queryTargetContCheckItemStateListRespDto_1 != null) {
            retData.setTargetContCheckItemStateList(queryTargetContCheckItemStateListRespDto_1.getTargetContCheckItemStateList().stream().map(item -> BeanUtil.toBean(item, BffTargetContCheckItemStateDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:544163_1
        }


        return retData;
    }

    /**
     * B3执行周期校验检查项更新(管理)[6035]
     * gen by moon at 7/14/2023, 11:02:17 AM
     */
    @Trace(operationName = "B3执行周期校验检查项更新(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementCycleVerifyCheckItemUpdateRespDto implementCycleVerifyCheckItemUpdate(BffImplementCycleVerifyCheckItemUpdateReqDto reqDto) {


        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 = null;
//virtualUsage D3执行进度运行判断(公共)  47590
        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
        ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto = new ImplementExecuteProgressOperationJudgeComReqDto();
        implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_CYCLE_CHECK");//CUSTOM_CONVENTION//sourceId:1086286_1_47590
        if (reqDto != null) {
            implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1086285_1_47590
            implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086287_1_47590
        }

        /*D3执行进度运行判断(公共)[7243]   */
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(), "B3执行周期校验检查项更新(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(), "B3执行周期校验检查项更新(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(), "B3执行周期校验检查项更新(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空", false);
        implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
        if ((implementExecuteProgressOperationJudgeComRespDto != null && implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null)) {
            //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47591

            ImplementCycleVerifyCheckItemUpdateRespDto implementCycleVerifyCheckItemUpdateRespDto = null;
            ImplementCycleVerifyCheckItemUpdateReqDto implementCycleVerifyCheckItemUpdateReqDto = new ImplementCycleVerifyCheckItemUpdateReqDto();
            if (reqDto != null) {
                implementCycleVerifyCheckItemUpdateReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:731099_1_47592
                implementCycleVerifyCheckItemUpdateReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:731093_1_47592
                implementCycleVerifyCheckItemUpdateReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:731094_1_47592
                implementCycleVerifyCheckItemUpdateReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:731095_1_47592
                implementCycleVerifyCheckItemUpdateReqDto.setTreeTypeCode(reqDto.getTreeTypeCode());//SimpleFieldAssign//sourceId:731096_1_47592
                implementCycleVerifyCheckItemUpdateReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:731097_1_47592
                implementCycleVerifyCheckItemUpdateReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:731098_1_47592
                implementCycleVerifyCheckItemUpdateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:731092_1_47592
                implementCycleVerifyCheckItemUpdateReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1036924_1_47592
            }

            /*D3执行周期校验检查项更新[6021]   */
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaObjTargetCycleCode(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-被评对象目标周期标识不能为空", false);
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaObjEntityId(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-被评对象内容表主键ID不能为空", false);
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaObjTableTypeCode(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-被评对象内容表类型编码不能为空", false);
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaObjTypeCode(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-被评对象类型编码不能为空", false);
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getTreeTypeCode(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-树类型编码不能为空", false);
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getTargetCycleContentTypeCode(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-关联目标内容类型编码不能为空", false);
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getTargetCycleContentId(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-关联目标内容ID不能为空", false);
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getEvaluationTemplateId(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-冗余评价模板ID不能为空", false);
            Assert.isNull(implementCycleVerifyCheckItemUpdateReqDto.getBatchOperateScene(), "B3执行周期校验检查项更新(管理)-D3执行周期校验检查项更新-高/中/基层操作场景不能为空", false);
            implementCycleVerifyCheckItemUpdateRespDto = fwAppOffStateClient.implementCycleVerifyCheckItemUpdate(implementCycleVerifyCheckItemUpdateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        BffImplementCycleVerifyCheckItemUpdateRespDto retData = new BffImplementCycleVerifyCheckItemUpdateRespDto();
        if (implementExecuteProgressOperationJudgeComRespDto_1 != null) {
            retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086289_1
        }


        return retData;
    }

    /**
     * B3执行强托底更新目标分类祖先父子状态等(管理)[6036]
     * gen by moon at 3/6/2023, 10:17:30 AM
     */
    @Trace(operationName = "B3执行强托底更新目标分类祖先父子状态等(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementForceTorrUpdateCategoryAncestorNodeStatusETCRespDto implementForceTorrUpdateCategoryAncestorNodeStatusETC(BffImplementForceTorrUpdateCategoryAncestorNodeStatusETCReqDto reqDto) {


        //步骤0: D3执行补偿强托底更新祖先父子状态等 - implementCompensateTorrUpdateAncestorNodeStatusEtc
        ImplementCompensateTorrUpdateAncestorNodeStatusEtcRespDto implementCompensateTorrUpdateAncestorNodeStatusEtcRespDto = null;
        ImplementCompensateTorrUpdateAncestorNodeStatusEtcReqDto implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto = new ImplementCompensateTorrUpdateAncestorNodeStatusEtcReqDto();
        if (reqDto != null) {
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:731108_1
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:731109_1
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:731110_1
        }

        /*D3执行补偿强托底更新祖先父子状态等[6026]   */
        Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getTableTypeCode(), "B3执行强托底更新目标分类祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-冗余内容表类型编码不能为空", false);
        Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getEntityId(), "B3执行强托底更新目标分类祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-冗余内容表主键ID不能为空", false);
        Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getEvaluationTemplateId(), "B3执行强托底更新目标分类祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-冗余评价模板ID不能为空", false);
        implementCompensateTorrUpdateAncestorNodeStatusEtcRespDto = fwAppOffStateClient.implementCompensateTorrUpdateAncestorNodeStatusEtc(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto).getData();


        BffImplementForceTorrUpdateCategoryAncestorNodeStatusETCRespDto retData = new BffImplementForceTorrUpdateCategoryAncestorNodeStatusETCRespDto();


        return retData;
    }

    /**
     * B3执行目标校验检查项更新(管理)[6037]
     * gen by moon at 7/14/2023, 11:02:20 AM
     */
    @Trace(operationName = "B3执行目标校验检查项更新(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementTargetValueVerifyCheckItemUpdateRespDto implementTargetValueVerifyCheckItemUpdate(BffImplementTargetValueVerifyCheckItemUpdateReqDto reqDto) {


        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 = null;
//virtualUsage D3执行进度运行判断(公共)  47597
        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
        ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto = new ImplementExecuteProgressOperationJudgeComReqDto();
        implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_TARGET_VALUE_CHECK");//CUSTOM_CONVENTION//sourceId:1086296_1_47597
        if (reqDto != null) {
            implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1086295_1_47597
            implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086297_1_47597
        }

        /*D3执行进度运行判断(公共)[7243]   */
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(), "B3执行目标校验检查项更新(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(), "B3执行目标校验检查项更新(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(), "B3执行目标校验检查项更新(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空", false);
        implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
        if ((implementExecuteProgressOperationJudgeComRespDto != null && implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null)) {
            //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47598

            ImplementTargetValueVerifyCheckItemUpdateRespDto implementTargetValueVerifyCheckItemUpdateRespDto = null;
            ImplementTargetValueVerifyCheckItemUpdateReqDto implementTargetValueVerifyCheckItemUpdateReqDto = new ImplementTargetValueVerifyCheckItemUpdateReqDto();
            if (reqDto != null) {
                implementTargetValueVerifyCheckItemUpdateReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:731169_1_47599
                implementTargetValueVerifyCheckItemUpdateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:731170_1_47599
                implementTargetValueVerifyCheckItemUpdateReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1037022_1_47599
            }

            /*D3执行目标校验检查项更新[6022]   */
            Assert.isNull(implementTargetValueVerifyCheckItemUpdateReqDto.getEntityId(), "B3执行目标校验检查项更新(管理)-D3执行目标校验检查项更新-冗余内容表主键ID不能为空", false);
            Assert.isNull(implementTargetValueVerifyCheckItemUpdateReqDto.getEvaluationTemplateId(), "B3执行目标校验检查项更新(管理)-D3执行目标校验检查项更新-冗余评价模板ID不能为空", false);
            Assert.isNull(implementTargetValueVerifyCheckItemUpdateReqDto.getBatchOperateScene(), "B3执行目标校验检查项更新(管理)-D3执行目标校验检查项更新-高/中/基层操作场景不能为空", false);
            implementTargetValueVerifyCheckItemUpdateRespDto = fwAppOffStateClient.implementTargetValueVerifyCheckItemUpdate(implementTargetValueVerifyCheckItemUpdateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        BffImplementTargetValueVerifyCheckItemUpdateRespDto retData = new BffImplementTargetValueVerifyCheckItemUpdateRespDto();
        if (implementExecuteProgressOperationJudgeComRespDto_1 != null) {
            retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086299_1
        }


        return retData;
    }

    /**
     * B3执行强托底更新目标内容祖先父子状态等(管理)[6036]
     * gen by moon at 3/26/2023, 8:00:38 PM
     */
    @Trace(operationName = "B3执行强托底更新目标内容祖先父子状态等(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementForceTorrUpdateTargetContAncestorNodeStatusEtcRespDto implementForceTorrUpdateTargetContAncestorNodeStatusEtc(BffImplementForceTorrUpdateTargetContAncestorNodeStatusEtcReqDto reqDto) {


        //步骤0: D3执行补偿强托底更新祖先父子状态等 - implementCompensateTorrUpdateAncestorNodeStatusEtc
        ImplementCompensateTorrUpdateAncestorNodeStatusEtcRespDto implementCompensateTorrUpdateAncestorNodeStatusEtcRespDto = null;
        ImplementCompensateTorrUpdateAncestorNodeStatusEtcReqDto implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto = new ImplementCompensateTorrUpdateAncestorNodeStatusEtcReqDto();
        if (reqDto != null) {
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setCheckItemCode(reqDto.getCheckItemCode());//SimpleFieldAssign//sourceId:783290_1
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:783291_1
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:783292_1
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:783293_1
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:731108_1
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:731109_1
            implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:731110_1
        }

        /*D3执行补偿强托底更新祖先父子状态等[6026]   */
        Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getEvaObjTypeCode(), "B3执行强托底更新目标内容祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-被评对象类型编码不能为空", false);
        Assert.isNull(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto.getEvaluationTemplateId(), "B3执行强托底更新目标内容祖先父子状态等(管理)-D3执行补偿强托底更新祖先父子状态等-冗余评价模板ID不能为空", false);
        implementCompensateTorrUpdateAncestorNodeStatusEtcRespDto = fwAppOffStateClient.implementCompensateTorrUpdateAncestorNodeStatusEtc(implementCompensateTorrUpdateAncestorNodeStatusEtcReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementForceTorrUpdateTargetContAncestorNodeStatusEtcRespDto retData = new BffImplementForceTorrUpdateTargetContAncestorNodeStatusEtcRespDto();


        return retData;
    }

    /**
     * B3查询部门目标任务书父子状态列表(管理)[6105]
     * gen by moon at 6/5/2023, 6:41:36 AM
     */
    @Trace(operationName = "B3查询部门目标任务书父子状态列表(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffQueryDeptTargetBookTreeParentStateListRespDto queryDeptTargetBookTreeParentStateList(BffQueryDeptTargetBookTreeParentStateListReqDto reqDto) {


        BatchQueryDeptTargetBookTreeParentStateListByIdsRespDto batchQueryDeptTargetBookTreeParentStateListByIdsRespDto_1 = null;
//步骤0: D3查询部门目标任务书父子状态列表ByIds - batchQueryDeptTargetBookTreeParentStateListByIds
        BatchQueryDeptTargetBookTreeParentStateListByIdsRespDto batchQueryDeptTargetBookTreeParentStateListByIdsRespDto = null;
        BatchQueryDeptTargetBookTreeParentStateListByIdsReqDto batchQueryDeptTargetBookTreeParentStateListByIdsReqDto = new BatchQueryDeptTargetBookTreeParentStateListByIdsReqDto();
        batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.setEmploySceneTypeCode("USED_DEPT_TARGET_TASK_WEIGHT_SET");//sourceId:1011384_1
        if (reqDto != null) {
            batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.setAssistNodeStatusList(reqDto.getAssistNodeStatusList());//list-field-assign//sourceId:763727_1
            batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:763712_1
        }

        /*D3查询部门目标任务书父子状态列表ByIds[6106]   */
        Assert.isNull(batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.getEmploySceneTypeCode(), "B3查询部门目标任务书父子状态列表(管理)-D3查询部门目标任务书父子状态列表ByIds-使用场景编码不能为空", false);
        Assert.isNull(batchQueryDeptTargetBookTreeParentStateListByIdsReqDto.getThemeContentId(), "B3查询部门目标任务书父子状态列表(管理)-D3查询部门目标任务书父子状态列表ByIds-主题内容ID不能为空", false);
        batchQueryDeptTargetBookTreeParentStateListByIdsRespDto = fwAppOffStateClient.batchQueryDeptTargetBookTreeParentStateListByIds(batchQueryDeptTargetBookTreeParentStateListByIdsReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        batchQueryDeptTargetBookTreeParentStateListByIdsRespDto_1 = batchQueryDeptTargetBookTreeParentStateListByIdsRespDto;

        BffQueryDeptTargetBookTreeParentStateListRespDto retData = new BffQueryDeptTargetBookTreeParentStateListRespDto();
        if (batchQueryDeptTargetBookTreeParentStateListByIdsRespDto_1 != null) {
            retData.setAssistNodeStatusList(batchQueryDeptTargetBookTreeParentStateListByIdsRespDto_1.getAssistNodeStatusList().stream().map(item -> BeanUtil.toBean(item, BffAssistNodeStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:763728_1
        }


        return retData;
    }

    /**
     * B3-11高层返回第一步(管理)[2987]
     * gen by moon at 2/7/2024, 4:39:10 AM
     */
    @Trace(operationName = "B3-11高层返回第一步(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateTopReturnFirstStepRespDto updateTopReturnFirstStep(BffUpdateTopReturnFirstStepReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2-执行并发行为主题锁(公共)  61094
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540005_1_61094
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540006_1_61094
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1540011_1_61094
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540012_1_61094
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540013_1_61094
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540007_1_61094
        }

        /*D2-执行并发行为主题锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行并发高中基层步骤变更上锁(公共).防并发上锁情况 等于 空上锁成功)  47482

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setRollbackPlanEditDiv("1");//CUSTOM_CONVENTION//sourceId:1203544_1_51036
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203545_1_51036
            if (reqDto != null) {
                implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203546_1_51036
            }

            /*D3执行高层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackPlanEditDiv(), "B3-11高层返回第一步(管理)-D3执行高层导向步骤房间-返回编制规划不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11高层返回第一步(管理)-D3执行高层导向步骤房间-高/中/基层操作场景不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(), "B3-11高层返回第一步(管理)-D3执行高层导向步骤房间-权重设置方式不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1089806_1_47713
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1089802_1_47713
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1089803_1_47713
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1089805_1_47713
                }

                /*D3执行高层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3-11高层返回第一步(管理)-D3执行高层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3-11高层返回第一步(管理)-D3执行高层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3-11高层返回第一步(管理)-D3执行高层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3-11高层返回第一步(管理)-D3执行高层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
                //if(D3执行高中基层当前步骤判断(公共).是否相等 等于 否)  47714

                UpdateTopReturnFirstStepComRespDto updateTopReturnFirstStepComRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    UpdateTopReturnFirstStepComReqDto updateTopReturnFirstStepComReqDto = new UpdateTopReturnFirstStepComReqDto();
                    if (reqDto != null) {
                        updateTopReturnFirstStepComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:870610_1_47716
                        updateTopReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:665946_1_47716
                        updateTopReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:847693_1_47716
                        updateTopReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856594_1_47716
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        updateTopReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:847692_1_47716
                    }

                    /*D3-11高层返回第一步(公共)[3752]   */
                    Assert.isNull(updateTopReturnFirstStepComReqDto.getTargetId(), "B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-冗余目标ID不能为空", false);
                    Assert.isNull(updateTopReturnFirstStepComReqDto.getEvaluationTemplateId(), "B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(updateTopReturnFirstStepComReqDto.getStepRoomValue(), "B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-进入步骤房间值不能为空", false);
                    Assert.isNull(updateTopReturnFirstStepComReqDto.getBatchCode(), "B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-批次标识不能为空", false);
                    Assert.isNull(updateTopReturnFirstStepComReqDto.getBatchCurrentStatus(), "B3-11高层返回第一步(管理)-D3-11高层返回第一步(公共)-批次现状不能为空", false);
                    updateTopReturnFirstStepComRespDto = fwAppOffStateClient.updateTopReturnFirstStepCom(updateTopReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540016_1_61097
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540017_1_61097
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540025_1_61097
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540018_1_61097
                }

                /*D2-执行并发行为主题锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3-11高层返回第一步(管理)-D2-执行并发行为主题锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行高层当前步骤判断(公共).是否相等 等于 是)  61098

//异常结束 61150
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行并发高中基层步骤变更上锁(公共).防并发上锁情况 等于 并发上锁失败)  61095

//异常结束 61096
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffUpdateTopReturnFirstStepRespDto retData = new BffUpdateTopReturnFirstStepRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203547_1
        }


        return retData;
    }

    /**
     * B3-11高层返回第二步(管理)[2990]
     * gen by moon at 2/24/2024, 9:12:08 PM
     */
    @Trace(operationName = "B3-11高层返回第二步(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateTopReturnSecondStepRespDto updateTopReturnSecondStep(BffUpdateTopReturnSecondStepReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2执行上并发高中基层步骤变更锁(公共)  61139
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540170_1_61139
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540171_1_61139
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540173_1_61139
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540174_1_61139
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540175_1_61139
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540172_1_61139
        }

        /*D2执行上并发高中基层步骤变更锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3-11高层返回第二步(管理)-D2执行上并发高中基层步骤变更锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  61140

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setRollbackTargetDiv("1");//CUSTOM_CONVENTION//sourceId:1203567_1_61143
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("TOP");//sourceId:1203568_1_61143
            if (reqDto != null) {
                implementTopMidBasicGuideStepRoomReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1203569_1_61143
            }

            /*D3执行高层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackTargetDiv(), "B3-11高层返回第二步(管理)-D3执行高层导向步骤房间-返回目标任务分工不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-11高层返回第二步(管理)-D3执行高层导向步骤房间-高/中/基层操作场景不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getWeightSetWay(), "B3-11高层返回第二步(管理)-D3执行高层导向步骤房间-权重设置方式不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("TOP");//sourceId:1203827_1_61144
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203823_1_61144
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203824_1_61144
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203826_1_61144
                }

                /*D3执行高层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3-11高层返回第二步(管理)-D3执行高层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3-11高层返回第二步(管理)-D3执行高层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3-11高层返回第二步(管理)-D3执行高层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3-11高层返回第二步(管理)-D3执行高层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
                //if(D3执行高层当前步骤判断(公共).是否相等 等于 否)  61145

                UpdateTopReturnSecondStepRespDto updateTopReturnSecondStepRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    UpdateTopReturnSecondStepReqDto updateTopReturnSecondStepReqDto = new UpdateTopReturnSecondStepReqDto();
                    if (reqDto != null) {
                        updateTopReturnSecondStepReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:850255_1_61146
                        updateTopReturnSecondStepReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:857501_1_61146
                        updateTopReturnSecondStepReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:857502_1_61146
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        updateTopReturnSecondStepReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1203583_1_61146
                    }


                    /*D3-11修改高层返回第二步[3001]   */
                    Assert.isNull(updateTopReturnSecondStepReqDto.getEvaluationTemplateId(), "B3-11高层返回第二步(管理)-D3-11修改高层返回第二步-冗余评价模板ID不能为空", false);
                    Assert.isNull(updateTopReturnSecondStepReqDto.getStepRoomValue(), "B3-11高层返回第二步(管理)-D3-11修改高层返回第二步-进入步骤房间值不能为空", false);
                    Assert.isNull(updateTopReturnSecondStepReqDto.getBatchCode(), "B3-11高层返回第二步(管理)-D3-11修改高层返回第二步-批次标识不能为空", false);
                    Assert.isNull(updateTopReturnSecondStepReqDto.getBatchCurrentStatus(), "B3-11高层返回第二步(管理)-D3-11修改高层返回第二步-批次现状不能为空", false);
                    updateTopReturnSecondStepRespDto = fwAppOffStateClient.updateTopReturnSecondStep(updateTopReturnSecondStepReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540176_1_61147
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540177_1_61147
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540179_1_61147
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1540178_1_61147
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3-11高层返回第二步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3-11高层返回第二步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3-11高层返回第二步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3-11高层返回第二步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行高层当前步骤判断(公共).是否相等 等于 是)  61148

//异常结束 61149
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行上并发高中基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61141

//异常结束 61142
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffUpdateTopReturnSecondStepRespDto retData = new BffUpdateTopReturnSecondStepRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203584_1
        }


        return retData;
    }

    /**
     * B3-3中层返回第一步(管理)[3038]
     * gen by moon at 2/24/2024, 1:08:43 PM
     */
    @Trace(operationName = "B3-3中层返回第一步(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateMidReturnFirstStepRespDto updateMidReturnFirstStep(BffUpdateMidReturnFirstStepReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2执行上并发中层步骤变更锁(公共)  61201
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540363_1_61201
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540364_1_61201
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1540366_1_61201
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540367_1_61201
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540368_1_61201
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540365_1_61201
        }

        /*D2执行上并发中层步骤变更锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3-3中层返回第一步(管理)-D2执行上并发中层步骤变更锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  47507

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setRollbackLeaderTargetDiv("1");//CUSTOM_CONVENTION//sourceId:1203797_1_51061
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("MID");//sourceId:1203798_1_51061
            if (reqDto != null) {
                implementTopMidBasicGuideStepRoomReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1203799_1_51061
                implementTopMidBasicGuideStepRoomReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203800_1_51061
            }

            /*D3执行中层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackLeaderTargetDiv(), "B3-3中层返回第一步(管理)-D3执行中层导向步骤房间-返回牵头目标安排不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3-3中层返回第一步(管理)-D3执行中层导向步骤房间-高/中/基层操作场景不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptId(), "B3-3中层返回第一步(管理)-D3执行中层导向步骤房间-一级部门ID不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEvaluationTemplateId(), "B3-3中层返回第一步(管理)-D3执行中层导向步骤房间-冗余评价模板ID不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("MID");//sourceId:1091553_1_47738
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1091549_1_47738
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1091550_1_47738
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1091552_1_47738
                }

                /*D3执行中层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3-3中层返回第一步(管理)-D3执行中层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3-3中层返回第一步(管理)-D3执行中层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3-3中层返回第一步(管理)-D3执行中层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3-3中层返回第一步(管理)-D3执行中层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
                //if(D3执行中层当前步骤判断(公共).是否相等 等于 否)  47739

                ImplementMidReturnFirstStepComRespDto implementMidReturnFirstStepComRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    ImplementMidReturnFirstStepComReqDto implementMidReturnFirstStepComReqDto = new ImplementMidReturnFirstStepComReqDto();
                    implementMidReturnFirstStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1091556_1_47740
                    if (reqDto != null) {
                        implementMidReturnFirstStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:849253_1_47740
                        implementMidReturnFirstStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:849254_1_47740
                        implementMidReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:849255_1_47740
                        implementMidReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:849257_1_47740
                        implementMidReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856642_1_47740
                        implementMidReturnFirstStepComReqDto.setOrgInductionRecordList(reqDto.getOrgInductionRecordList());//list-field-assign//sourceId:1550907_1_47740
                        implementMidReturnFirstStepComReqDto.setBackMsgSendType(reqDto.getBackMsgSendType());//SimpleFieldAssign//sourceId:1550908_1_47740
                        implementMidReturnFirstStepComReqDto.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1550909_1_47740
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        implementMidReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:849256_1_47740
                    }

                    /*D3执行中层返回第一步(公共)[3748]   */
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptId(), "B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-部门ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptTargetTaskBookId(), "B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-部门目标任务书ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getEvaluationTemplateId(), "B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getStepRoomValue(), "B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-进入步骤房间值不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCode(), "B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-批次标识不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCurrentStatus(), "B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-批次现状不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getUseTypeCode(), "B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-用途类型编码不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getBackMsgSendType(), "B3-3中层返回第一步(管理)-D3执行中层返回第一步(公共)-回退消息发送类型不能为空", false);
                    implementMidReturnFirstStepComRespDto = fwAppOffStateClient.implementMidReturnFirstStepCom(implementMidReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540369_1_61202
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540370_1_61202
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540372_1_61202
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540371_1_61202
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3-3中层返回第一步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3-3中层返回第一步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3-3中层返回第一步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3-3中层返回第一步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行中层当前步骤判断(公共).是否相等 等于 是)  61203

//异常结束 61204
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61205

//异常结束 61206
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffUpdateMidReturnFirstStepRespDto retData = new BffUpdateMidReturnFirstStepRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203801_1
        }


        return retData;
    }

    /**
     * B3中层返回第二步(管理)[3046]
     * gen by moon at 2/24/2024, 1:08:50 PM
     */
    @Trace(operationName = "B3中层返回第二步(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateMidReturnSecondStepRespDto updateMidReturnSecondStep(BffUpdateMidReturnSecondStepReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2执行上并发中层步骤变更锁(公共)  61191
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540330_1_61191
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540331_1_61191
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1540333_1_61191
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540334_1_61191
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540335_1_61191
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540332_1_61191
        }

        /*D2执行上并发中层步骤变更锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3中层返回第二步(管理)-D2执行上并发中层步骤变更锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  45921

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setRollbackExecuteTargetDiv("1");//CUSTOM_CONVENTION//sourceId:1203774_1_61192
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("MID");//sourceId:1203775_1_61192
            if (reqDto != null) {
                implementTopMidBasicGuideStepRoomReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1203776_1_61192
                implementTopMidBasicGuideStepRoomReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1203777_1_61192
            }

            /*D3执行中层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackExecuteTargetDiv(), "B3中层返回第二步(管理)-D3执行中层导向步骤房间-返回执行目标安排不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3中层返回第二步(管理)-D3执行中层导向步骤房间-高/中/基层操作场景不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getDeptId(), "B3中层返回第二步(管理)-D3执行中层导向步骤房间-一级部门ID不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getEvaluationTemplateId(), "B3中层返回第二步(管理)-D3执行中层导向步骤房间-冗余评价模板ID不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("MID");//sourceId:1091561_1_47752
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1091557_1_47752
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1091558_1_47752
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1091560_1_47752
                }

                /*D3执行中层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3中层返回第二步(管理)-D3执行中层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3中层返回第二步(管理)-D3执行中层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3中层返回第二步(管理)-D3执行中层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3中层返回第二步(管理)-D3执行中层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE") && implementTopMidBasicGuideStepRoomRespDto != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("EXECUTE_TARGET_ARRANGE_ROOM"))) {
                //if((D3执行中层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 执行目标安排房间))  47510

                ImplementMidReturnSecondStepComRespDto implementMidReturnSecondStepComRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    ImplementMidReturnSecondStepComReqDto implementMidReturnSecondStepComReqDto = new ImplementMidReturnSecondStepComReqDto();
                    implementMidReturnSecondStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1091564_1_47511
                    if (reqDto != null) {
                        implementMidReturnSecondStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:849272_1_47511
                        implementMidReturnSecondStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:849273_1_47511
                        implementMidReturnSecondStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:849274_1_47511
                        implementMidReturnSecondStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:849276_1_47511
                        implementMidReturnSecondStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856626_1_47511
                        implementMidReturnSecondStepComReqDto.setOrgInductionRecordList(reqDto.getOrgInductionRecordList());//list-field-assign//sourceId:1550927_1_47511
                        implementMidReturnSecondStepComReqDto.setBackMsgSendType(reqDto.getBackMsgSendType());//SimpleFieldAssign//sourceId:1550928_1_47511
                        implementMidReturnSecondStepComReqDto.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1550929_1_47511
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        implementMidReturnSecondStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:849275_1_47511
                    }

                    /*D3执行中层返回第二步(公共)[6330]   */
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getDeptId(), "B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-部门ID不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getDeptTargetTaskBookId(), "B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-部门目标任务书ID不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getEvaluationTemplateId(), "B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getStepRoomValue(), "B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-进入步骤房间值不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getBatchCode(), "B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-批次标识不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getBatchCurrentStatus(), "B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-批次现状不能为空", false);
                    Assert.isNull(implementMidReturnSecondStepComReqDto.getUseTypeCode(), "B3中层返回第二步(管理)-D3执行中层返回第二步(公共)-用途类型编码不能为空", false);
                    implementMidReturnSecondStepComRespDto = fwAppOffStateClient.implementMidReturnSecondStepCom(implementMidReturnSecondStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540336_1_61193
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540337_1_61193
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540339_1_61193
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540338_1_61193
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE") && implementTopMidBasicGuideStepRoomRespDto != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue() != null && implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue().equals("LEAD_TARGET_ARRANGE_ROOM"))) {
                //elseif((D3执行中层当前步骤判断(公共).是否相等 等于 否 and D3执行中层导向步骤房间.进入步骤房间值 等于 牵头目标安排房间))  61194

                ImplementMidReturnFirstStepComRespDto implementMidReturnFirstStepComRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    ImplementMidReturnFirstStepComReqDto implementMidReturnFirstStepComReqDto = new ImplementMidReturnFirstStepComReqDto();
                    implementMidReturnFirstStepComReqDto.setUseTypeCode("USE_MID_ISSUE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1091565_1_61195
                    if (reqDto != null) {
                        implementMidReturnFirstStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1052648_1_61195
                        implementMidReturnFirstStepComReqDto.setDeptTargetTaskBookId(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1052644_1_61195
                        implementMidReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1052645_1_61195
                        implementMidReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1052647_1_61195
                        implementMidReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1052650_1_61195
                        implementMidReturnFirstStepComReqDto.setOrgInductionRecordList(reqDto.getOrgInductionRecordList());//list-field-assign//sourceId:1550930_1_61195
                        implementMidReturnFirstStepComReqDto.setBackMsgSendType(reqDto.getBackMsgSendType());//SimpleFieldAssign//sourceId:1550931_1_61195
                        implementMidReturnFirstStepComReqDto.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1550932_1_61195
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        implementMidReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1052646_1_61195
                    }

                    /*D3执行中层返回第一步(公共)[3748]   */
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptId(), "B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-部门ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getDeptTargetTaskBookId(), "B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-部门目标任务书ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getEvaluationTemplateId(), "B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getStepRoomValue(), "B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-进入步骤房间值不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCode(), "B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-批次标识不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getBatchCurrentStatus(), "B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-批次现状不能为空", false);
                    Assert.isNull(implementMidReturnFirstStepComReqDto.getUseTypeCode(), "B3中层返回第二步(管理)-D3执行中层返回第一步(公共)-用途类型编码不能为空", false);
                    implementMidReturnFirstStepComRespDto = fwAppOffStateClient.implementMidReturnFirstStepCom(implementMidReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_3 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_2 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_2.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540336_1_61196
                implementConcBhvThemeLockComComReqDto_2.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540337_1_61196
                implementConcBhvThemeLockComComReqDto_2.setWhetherUnlockBulk("FALSE");//sourceId:1540339_1_61196
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_2.setCommPrimaryKey(reqDto.getDeptTargetTaskBookId());//SimpleFieldAssign//sourceId:1540338_1_61196
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getPreventConcurrentLockingUnlocking(), "B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getBehaviorThemeLockCode(), "B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getCommPrimaryKey(), "B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_2.getWhetherUnlockBulk(), "B3中层返回第二步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_3 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行中层当前步骤判断(公共).是否相等 等于 是)  61197

//异常结束 61198
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行上并发中层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61199

//异常结束 61200
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffUpdateMidReturnSecondStepRespDto retData = new BffUpdateMidReturnSecondStepRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1540340_1
        }


        return retData;
    }

    /**
     * B3基层返回第一步(管理)[3060]
     * gen by moon at 2/24/2024, 1:08:57 PM
     */
    @Trace(operationName = "B3基层返回第一步(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateGrootsReturnFirstStepRespDto updateGrootsReturnFirstStep(BffUpdateGrootsReturnFirstStepReqDto reqDto) {


        ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto_1 = null;
//virtualUsage D2执行上并发基层步骤变更锁(公共)  61223
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1540444_1_61223
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540445_1_61223
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1540450_1_61223
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1540451_1_61223
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1540452_1_61223
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:1540446_1_61223
        }

        /*D2执行上并发基层步骤变更锁(公共)[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-行为主题锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "B3基层返回第一步(管理)-D2执行上并发基层步骤变更锁(公共)-并发上锁失败处理方式不能为空", false);
        implementConcBhvThemeLockComComRespDto = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行上并发基层步骤变更锁(公共).防并发上锁情况 等于 空上锁成功)  47516

            ImplementTopMidBasicGuideStepRoomRespDto implementTopMidBasicGuideStepRoomRespDto = null;
            ImplementTopMidBasicGuideStepRoomReqDto implementTopMidBasicGuideStepRoomReqDto = new ImplementTopMidBasicGuideStepRoomReqDto();
            implementTopMidBasicGuideStepRoomReqDto.setRollbackExecuteTargetDiv("1");//CUSTOM_CONVENTION//sourceId:1203820_1_51062
            implementTopMidBasicGuideStepRoomReqDto.setBatchOperateScene("BASIC");//sourceId:1203821_1_51062

            /*D3基层导向步骤房间[7600]   */
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getRollbackExecuteTargetDiv(), "B3基层返回第一步(管理)-D3基层导向步骤房间-返回执行目标安排不能为空", false);
            Assert.isNull(implementTopMidBasicGuideStepRoomReqDto.getBatchOperateScene(), "B3基层返回第一步(管理)-D3基层导向步骤房间-高/中/基层操作场景不能为空", false);
            implementTopMidBasicGuideStepRoomRespDto = fwAppEvaSystemClient.implementTopMidBasicGuideStepRoom(implementTopMidBasicGuideStepRoomReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            implementTopMidBasicGuideStepRoomRespDto_1 = implementTopMidBasicGuideStepRoomRespDto;
            ImplementTopMidBasicCurrentBstepJudgeComRespDto implementTopMidBasicCurrentBstepJudgeComRespDto = null;
            if (implementTopMidBasicGuideStepRoomRespDto != null) {
                ImplementTopMidBasicCurrentBstepJudgeComReqDto implementTopMidBasicCurrentBstepJudgeComReqDto = new ImplementTopMidBasicCurrentBstepJudgeComReqDto();
                implementTopMidBasicCurrentBstepJudgeComReqDto.setBatchOperateScene("BASIC");//sourceId:1091585_1_47757
                if (reqDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setEntityId(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:1091581_1_47757
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1091582_1_47757
                }
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    implementTopMidBasicCurrentBstepJudgeComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:1091584_1_47757
                }

                /*D3执行基层当前步骤判断(公共)[7303]   */
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getEntityId(), "B3基层返回第一步(管理)-D3执行基层当前步骤判断(公共)-步骤内容实例ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getStepRoomValue(), "B3基层返回第一步(管理)-D3执行基层当前步骤判断(公共)-进入步骤房间值不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getThemeContentId(), "B3基层返回第一步(管理)-D3执行基层当前步骤判断(公共)-主题内容ID不能为空", false);
                Assert.isNull(implementTopMidBasicCurrentBstepJudgeComReqDto.getBatchOperateScene(), "B3基层返回第一步(管理)-D3执行基层当前步骤判断(公共)-高/中/基层操作场景不能为空", false);
                implementTopMidBasicCurrentBstepJudgeComRespDto = fwAppOffStateClient.implementTopMidBasicCurrentBstepJudgeCom(implementTopMidBasicCurrentBstepJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("FALSE"))) {
                //if(D3执行基层当前步骤判断(公共).是否相等 等于 否)  47758

                ImplementGrootsReturnFirstStepComRespDto implementGrootsReturnFirstStepComRespDto = null;
                if (implementTopMidBasicGuideStepRoomRespDto != null) {
                    ImplementGrootsReturnFirstStepComReqDto implementGrootsReturnFirstStepComReqDto = new ImplementGrootsReturnFirstStepComReqDto();
                    implementGrootsReturnFirstStepComReqDto.setUseTypeCode("USE_BASIC_ISSUE_EXECUTE_OBJTIVE");//CUSTOM_CONVENTION//sourceId:1091588_1_47760
                    if (reqDto != null) {
                        implementGrootsReturnFirstStepComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:849500_1_47760
                        implementGrootsReturnFirstStepComReqDto.setDeptOkrTargetId(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:849501_1_47760
                        implementGrootsReturnFirstStepComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:849502_1_47760
                        implementGrootsReturnFirstStepComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:849504_1_47760
                        implementGrootsReturnFirstStepComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:856658_1_47760
                        implementGrootsReturnFirstStepComReqDto.setOrgInductionRecordList(reqDto.getOrgInductionRecordList());//list-field-assign//sourceId:1550881_1_47760
                        implementGrootsReturnFirstStepComReqDto.setBackMsgSendType(reqDto.getBackMsgSendType());//SimpleFieldAssign//sourceId:1550879_1_47760
                        implementGrootsReturnFirstStepComReqDto.setMessageContent(reqDto.getMessageContent());//SimpleFieldAssign//sourceId:1550880_1_47760
                    }
                    if (implementTopMidBasicGuideStepRoomRespDto != null) {
                        implementGrootsReturnFirstStepComReqDto.setStepRoomValue(implementTopMidBasicGuideStepRoomRespDto.getStepRoomValue());//SimpleFieldAssign//sourceId:849503_1_47760
                    }

                    /*D3执行基层返回第一步(公共)[6331]   */
                    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getDeptId(), "B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-部门ID不能为空", false);
                    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getDeptOkrTargetId(), "B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-部门OKR目标ID不能为空", false);
                    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getEvaluationTemplateId(), "B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getStepRoomValue(), "B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-进入步骤房间值不能为空", false);
                    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getBatchCode(), "B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-批次标识不能为空", false);
                    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getBatchCurrentStatus(), "B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-批次现状不能为空", false);
                    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getUseTypeCode(), "B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-用途类型编码不能为空", false);
                    Assert.isNull(implementGrootsReturnFirstStepComReqDto.getBackMsgSendType(), "B3基层返回第一步(管理)-D3执行基层返回第一步(公共)-回退消息发送类型不能为空", false);
                    implementGrootsReturnFirstStepComRespDto = fwAppOffStateClient.implementGrootsReturnFirstStepCom(implementGrootsReturnFirstStepComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
                ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
                implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1540466_1_61224
                implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("TOP_MID_BASIC_STEP_CHANGE_SWIPES");//sourceId:1540467_1_61224
                implementConcBhvThemeLockComComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1540469_1_61224
                if (reqDto != null) {
                    implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getDeptOkrTargetId());//SimpleFieldAssign//sourceId:1540468_1_61224
                }

                /*D2执行并发行为主题解锁(公共)[8388]   */
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "B3基层返回第一步(管理)-D2执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "B3基层返回第一步(管理)-D2执行并发行为主题解锁(公共)-行为主题锁不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "B3基层返回第一步(管理)-D2执行并发行为主题解锁(公共)-通用主键ID不能为空", false);
                Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getWhetherUnlockBulk(), "B3基层返回第一步(管理)-D2执行并发行为主题解锁(公共)-是否批量解锁不能为空", false);
                implementConcBhvThemeLockComComRespDto_2 = fwCompInterfaceModeClient.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            } else if ((implementTopMidBasicCurrentBstepJudgeComRespDto != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse() != null && implementTopMidBasicCurrentBstepJudgeComRespDto.getTureOrFalse().equals("TRUE"))) {
                //elseif(D3执行基层当前步骤判断(公共).是否相等 等于 是)  61225

//异常结束 61226
                throw new BizException("B10100289", "对不起！当前房间已变化，请刷新页面~", false);
            }
        } else if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("CONCURRENT_LOCK_FAILURE"))) {
            //elseif(D2执行上并发基层步骤变更锁(公共).防并发上锁情况 等于 并发上锁失败)  61227

//异常结束 61228
            throw new BizException("B10100288", "操作过于频繁，请稍后再试~", false);
        }
        BffUpdateGrootsReturnFirstStepRespDto retData = new BffUpdateGrootsReturnFirstStepRespDto();
        if (implementTopMidBasicGuideStepRoomRespDto_1 != null) {
            retData.setStepNameCode(implementTopMidBasicGuideStepRoomRespDto_1.getStepNameCode());//SimpleFieldAssign//sourceId:1203822_1
        }


        return retData;
    }

    /**
     * B3执行中基层刷新父子状态(管理)[6578]
     * gen by moon at 7/13/2023, 4:47:48 PM
     */
    @Trace(operationName = "B3执行中基层刷新父子状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementMidOrBasicRefreshParentSonStateRespDto implementMidOrBasicRefreshParentSonState(BffImplementMidOrBasicRefreshParentSonStateReqDto reqDto) {


        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 = null;
//virtualUsage D3执行进度运行判断(公共)  47527
        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
        ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto = new ImplementExecuteProgressOperationJudgeComReqDto();
        implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_BRUSH_PARENT_SUB_STATE");//CUSTOM_CONVENTION//sourceId:1086139_1_47527
        if (reqDto != null) {
            implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:1086138_1_47527
            implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086140_1_47527
        }

        /*D3执行进度运行判断(公共)[7243]   */
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(), "B3执行中基层刷新父子状态(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(), "B3执行中基层刷新父子状态(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(), "B3执行中基层刷新父子状态(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空", false);
        implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
        if ((implementExecuteProgressOperationJudgeComRespDto != null && implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null)) {
            //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47528

            ImplementMidOrBasicRefreshParentSonStateRespDto implementMidOrBasicRefreshParentSonStateRespDto = null;
            ImplementMidOrBasicRefreshParentSonStateReqDto implementMidOrBasicRefreshParentSonStateReqDto = new ImplementMidOrBasicRefreshParentSonStateReqDto();
            implementMidOrBasicRefreshParentSonStateReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:921554_1_47529
            implementMidOrBasicRefreshParentSonStateReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:921555_1_47529
            if (reqDto != null) {
                implementMidOrBasicRefreshParentSonStateReqDto.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:929892_1_47529
                implementMidOrBasicRefreshParentSonStateReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:921553_1_47529
                implementMidOrBasicRefreshParentSonStateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:921552_1_47529
            }

            /*D3执行中基层刷新父子状态[6570]   */
            Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getBatchSetId(), "B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-批次设置对象ID不能为空", false);
            Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getEvaObjEntityId(), "B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-被评对象内容表主键ID不能为空", false);
            Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getEvaObjTypeCode(), "B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-被评对象类型编码不能为空", false);
            Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getTargetId(), "B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-冗余目标ID不能为空", false);
            Assert.isNull(implementMidOrBasicRefreshParentSonStateReqDto.getEvaluationTemplateId(), "B3执行中基层刷新父子状态(管理)-D3执行中基层刷新父子状态-冗余评价模板ID不能为空", false);
            implementMidOrBasicRefreshParentSonStateRespDto = fwAppOffStateClient.implementMidOrBasicRefreshParentSonState(implementMidOrBasicRefreshParentSonStateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        BffImplementMidOrBasicRefreshParentSonStateRespDto retData = new BffImplementMidOrBasicRefreshParentSonStateRespDto();
        if (implementExecuteProgressOperationJudgeComRespDto_1 != null) {
            retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086142_1
        }


        return retData;
    }

    /**
     * B3执行刷新当前下级父子状态(管理)[6577]
     * gen by moon at 7/14/2023, 12:29:31 AM
     */
    @Trace(operationName = "B3执行刷新当前下级父子状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementRefreshCurrentSubordinateParentSonStateRespDto implementRefreshCurrentSubordinateParentSonState(BffImplementRefreshCurrentSubordinateParentSonStateReqDto reqDto) {


        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 = null;
//virtualUsage D3执行进度运行判断(公共)  47563
        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
        ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto = new ImplementExecuteProgressOperationJudgeComReqDto();
        implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_BRUSH_PARENT_SUB_STATE");//CUSTOM_CONVENTION//sourceId:1086224_1_47563
        if (reqDto != null) {
            implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getParentTargetContId());//SimpleFieldAssign//sourceId:1086223_1_47563
            implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086225_1_47563
        }

        /*D3执行进度运行判断(公共)[7243]   */
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(), "B3执行刷新当前下级父子状态(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(), "B3执行刷新当前下级父子状态(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(), "B3执行刷新当前下级父子状态(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空", false);
        implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
        if ((implementExecuteProgressOperationJudgeComRespDto != null && implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null)) {
            //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47564

            ImplementUpdateCurrentSubordinateParentSonStateRespDto implementUpdateCurrentSubordinateParentSonStateRespDto = null;
            ImplementUpdateCurrentSubordinateParentSonStateReqDto implementUpdateCurrentSubordinateParentSonStateReqDto = new ImplementUpdateCurrentSubordinateParentSonStateReqDto();
            implementUpdateCurrentSubordinateParentSonStateReqDto.setUseTypeCode("USE_BRUSH_PARENT_SUB_STATE");//CUSTOM_CONVENTION//sourceId:1078693_1_47565
            if (reqDto != null) {
                implementUpdateCurrentSubordinateParentSonStateReqDto.setParentTableTypeCode(reqDto.getParentTableTypeCode());//SimpleFieldAssign//sourceId:921966_1_47565
                implementUpdateCurrentSubordinateParentSonStateReqDto.setParentTargetContId(reqDto.getParentTargetContId());//SimpleFieldAssign//sourceId:921967_1_47565
                implementUpdateCurrentSubordinateParentSonStateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:921968_1_47565
            }

            /*D3执行更新当前下级内容父子状态[6580]   */
            Assert.isNull(implementUpdateCurrentSubordinateParentSonStateReqDto.getParentTableTypeCode(), "B3执行刷新当前下级父子状态(管理)-D3执行更新当前下级内容父子状态-父级内容表类型编码不能为空", false);
            Assert.isNull(implementUpdateCurrentSubordinateParentSonStateReqDto.getParentTargetContId(), "B3执行刷新当前下级父子状态(管理)-D3执行更新当前下级内容父子状态-父级内容表主键ID不能为空", false);
            Assert.isNull(implementUpdateCurrentSubordinateParentSonStateReqDto.getEvaluationTemplateId(), "B3执行刷新当前下级父子状态(管理)-D3执行更新当前下级内容父子状态-冗余评价模板ID不能为空", false);
            Assert.isNull(implementUpdateCurrentSubordinateParentSonStateReqDto.getUseTypeCode(), "B3执行刷新当前下级父子状态(管理)-D3执行更新当前下级内容父子状态-用途类型编码不能为空", false);
            implementUpdateCurrentSubordinateParentSonStateRespDto = fwAppTargetContentClient.implementUpdateCurrentSubordinateParentSonState(implementUpdateCurrentSubordinateParentSonStateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        BffImplementRefreshCurrentSubordinateParentSonStateRespDto retData = new BffImplementRefreshCurrentSubordinateParentSonStateRespDto();
        if (implementExecuteProgressOperationJudgeComRespDto_1 != null) {
            retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086227_1
        }


        return retData;
    }

    /**
     * B3执行高层刷新父子状态(管理)[6579]
     * gen by moon at 7/13/2023, 4:47:52 PM
     */
    @Trace(operationName = "B3执行高层刷新父子状态(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementTopRefreshParentSonStateRespDto implementTopRefreshParentSonState(BffImplementTopRefreshParentSonStateReqDto reqDto) {


        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto_1 = null;
//virtualUsage D3执行进度运行判断(公共)  47524
        ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
        ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto = new ImplementExecuteProgressOperationJudgeComReqDto();
        implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_BRUSH_PARENT_SUB_STATE");//CUSTOM_CONVENTION//sourceId:1086134_1_47524
        if (reqDto != null) {
            implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086133_1_47524
            implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1086135_1_47524
        }

        /*D3执行进度运行判断(公共)[7243]   */
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(), "B3执行高层刷新父子状态(管理)-D3执行进度运行判断(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(), "B3执行高层刷新父子状态(管理)-D3执行进度运行判断(公共)-用途类型编码不能为空", false);
        Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(), "B3执行高层刷新父子状态(管理)-D3执行进度运行判断(公共)-主题内容ID不能为空", false);
        implementExecuteProgressOperationJudgeComRespDto = fwAppExecuteProgressClient.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        implementExecuteProgressOperationJudgeComRespDto_1 = implementExecuteProgressOperationJudgeComRespDto;
        if ((implementExecuteProgressOperationJudgeComRespDto != null && implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null)) {
            //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  47525

            ImplementTopRefreshParentSonStateRespDto implementTopRefreshParentSonStateRespDto = null;
            ImplementTopRefreshParentSonStateReqDto implementTopRefreshParentSonStateReqDto = new ImplementTopRefreshParentSonStateReqDto();
            implementTopRefreshParentSonStateReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:921560_1_47526
            implementTopRefreshParentSonStateReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:921561_1_47526
            if (reqDto != null) {
                implementTopRefreshParentSonStateReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:921562_1_47526
            }

            /*D3执行高层刷新父子状态[6574]   */
            Assert.isNull(implementTopRefreshParentSonStateReqDto.getEvaObjEntityId(), "B3执行高层刷新父子状态(管理)-D3执行高层刷新父子状态-被评对象内容表主键ID不能为空", false);
            Assert.isNull(implementTopRefreshParentSonStateReqDto.getEvaObjTypeCode(), "B3执行高层刷新父子状态(管理)-D3执行高层刷新父子状态-被评对象类型编码不能为空", false);
            Assert.isNull(implementTopRefreshParentSonStateReqDto.getEvaluationTemplateId(), "B3执行高层刷新父子状态(管理)-D3执行高层刷新父子状态-冗余评价模板ID不能为空", false);
            implementTopRefreshParentSonStateRespDto = fwAppOffStateClient.implementTopRefreshParentSonState(implementTopRefreshParentSonStateReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        BffImplementTopRefreshParentSonStateRespDto retData = new BffImplementTopRefreshParentSonStateRespDto();
        if (implementExecuteProgressOperationJudgeComRespDto_1 != null) {
            retData.setCustomField(implementExecuteProgressOperationJudgeComRespDto_1.getCustomField());//SimpleFieldAssign//sourceId:1086137_1
        }


        return retData;
    }


}
